Z991239-5077 #comment 优化音量调节接口

Module/mod_interactivecontrol/InteractiveControl.xml

@@ -421,6 +421,51 @@
 				<param name="StrVideoName" type="string"/>
 			</req>
 		</twoway>
+		<!--»ñÈ¡ºô½Ð״̬-->
+		<twoway name="GetCallStatse" overlap="true">
+			<req>
+			</req>
+			<res>
+				<param name="iState" type="int"/>
+			</res>
+		</twoway>
+		<oneway name="HangupCall" overlap="true">
+		</oneway>
+		<twoway name="GetTransactionRecordState" overlap="true">
+			<req>
+			</req>
+			<res>
+				<param name="iRecordState" type="int"/>
+			</res>
+		</twoway>
+		<twoway name="GetHandfreeInVolume" overlap="true">
+			<req>
+			</req>
+			<res>
+				<param name="Volume" type="int"/>
+			</res>
+		</twoway>
+		<twoway name="SetHandfreeInVolume" overlap="true">
+			<req>
+				<param name="Volume" type="int"/>
+			</req>
+			<res>
+			</res>
+		</twoway>
+		<twoway name="GetPickupInVolume" overlap="true">
+			<req>
+			</req>
+			<res>
+				<param name="Volume" type="int"/>
+			</res>
+		</twoway>
+		<twoway name="SetPickupInVolume" overlap="true">
+			<req>
+				<param name="Volume" type="int"/>
+			</req>
+			<res>
+			</res>
+		</twoway>
 	</class>
 	
 

Module/mod_interactivecontrol/InteractiveControl_client_g.h

@@ -2269,6 +2269,314 @@ public:
 		return Error;
 	}
 
+	ErrorCodeEnum GetCallStatse(UIService_GetCallStatse_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(UIService_Method_GetCallStatse, UIService_MethodSignature_GetCallStatse, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum GetCallStatse(UIService_GetCallStatse_Req &Req, UIService_GetCallStatse_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = GetCallStatse(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum GetCallStatse(UIService_GetCallStatse_Req &Req, UIService_GetCallStatse_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = GetCallStatse(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum GetCallStatse(UIService_GetCallStatse_Req &Req, UIService_GetCallStatse_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = GetCallStatse(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum HangupCall()
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->OnewayCall(UIService_Method_HangupCall, UIService_MethodSignature_HangupCall, m_context);
+		m_context.clear();
+		return ret;
+	}
+
+	ErrorCodeEnum GetTransactionRecordState(UIService_GetTransactionRecordState_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(UIService_Method_GetTransactionRecordState, UIService_MethodSignature_GetTransactionRecordState, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum GetTransactionRecordState(UIService_GetTransactionRecordState_Req &Req, UIService_GetTransactionRecordState_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = GetTransactionRecordState(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum GetTransactionRecordState(UIService_GetTransactionRecordState_Req &Req, UIService_GetTransactionRecordState_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = GetTransactionRecordState(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum GetTransactionRecordState(UIService_GetTransactionRecordState_Req &Req, UIService_GetTransactionRecordState_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = GetTransactionRecordState(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum GetHandfreeInVolume(UIService_GetHandfreeInVolume_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(UIService_Method_GetHandfreeInVolume, UIService_MethodSignature_GetHandfreeInVolume, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum GetHandfreeInVolume(UIService_GetHandfreeInVolume_Req &Req, UIService_GetHandfreeInVolume_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = GetHandfreeInVolume(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum GetHandfreeInVolume(UIService_GetHandfreeInVolume_Req &Req, UIService_GetHandfreeInVolume_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = GetHandfreeInVolume(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum GetHandfreeInVolume(UIService_GetHandfreeInVolume_Req &Req, UIService_GetHandfreeInVolume_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = GetHandfreeInVolume(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum SetHandfreeInVolume(UIService_SetHandfreeInVolume_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(UIService_Method_SetHandfreeInVolume, UIService_MethodSignature_SetHandfreeInVolume, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum SetHandfreeInVolume(UIService_SetHandfreeInVolume_Req &Req, UIService_SetHandfreeInVolume_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = SetHandfreeInVolume(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum SetHandfreeInVolume(UIService_SetHandfreeInVolume_Req &Req, UIService_SetHandfreeInVolume_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = SetHandfreeInVolume(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum SetHandfreeInVolume(UIService_SetHandfreeInVolume_Req &Req, UIService_SetHandfreeInVolume_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = SetHandfreeInVolume(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum GetPickupInVolume(UIService_GetPickupInVolume_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(UIService_Method_GetPickupInVolume, UIService_MethodSignature_GetPickupInVolume, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum GetPickupInVolume(UIService_GetPickupInVolume_Req &Req, UIService_GetPickupInVolume_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = GetPickupInVolume(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum GetPickupInVolume(UIService_GetPickupInVolume_Req &Req, UIService_GetPickupInVolume_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = GetPickupInVolume(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum GetPickupInVolume(UIService_GetPickupInVolume_Req &Req, UIService_GetPickupInVolume_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = GetPickupInVolume(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum SetPickupInVolume(UIService_SetPickupInVolume_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(UIService_Method_SetPickupInVolume, UIService_MethodSignature_SetPickupInVolume, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum SetPickupInVolume(UIService_SetPickupInVolume_Req &Req, UIService_SetPickupInVolume_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = SetPickupInVolume(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum SetPickupInVolume(UIService_SetPickupInVolume_Req &Req, UIService_SetPickupInVolume_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = SetPickupInVolume(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum SetPickupInVolume(UIService_SetPickupInVolume_Req &Req, UIService_SetPickupInVolume_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = SetPickupInVolume(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
 
 	bool SafeDelete()
 	{

Module/mod_interactivecontrol/InteractiveControl_def_g.h

@@ -74,6 +74,13 @@ namespace InteractiveControl {
 #define UIService_Method_GetRecordMode 52
 #define UIService_Method_StartTransactionRecord 53
 #define UIService_Method_StopTransactionRecord 54
+#define UIService_Method_GetCallStatse 55
+#define UIService_Method_HangupCall 56
+#define UIService_Method_GetTransactionRecordState 57
+#define UIService_Method_GetHandfreeInVolume 58
+#define UIService_Method_SetHandfreeInVolume 59
+#define UIService_Method_GetPickupInVolume 60
+#define UIService_Method_SetPickupInVolume 61
 
 #define UIService_MethodSignature_SetUIState -649355360
 #define UIService_MethodSignature_SendAgentText -389826246
@@ -130,6 +137,13 @@ namespace InteractiveControl {
 #define UIService_MethodSignature_GetRecordMode -1617187757
 #define UIService_MethodSignature_StartTransactionRecord 339746588
 #define UIService_MethodSignature_StopTransactionRecord 1197230846
+#define UIService_MethodSignature_GetCallStatse -1446312706
+#define UIService_MethodSignature_HangupCall 478500367
+#define UIService_MethodSignature_GetTransactionRecordState -923839253
+#define UIService_MethodSignature_GetHandfreeInVolume -973146972
+#define UIService_MethodSignature_SetHandfreeInVolume -1471315400
+#define UIService_MethodSignature_GetPickupInVolume -735373015
+#define UIService_MethodSignature_SetPickupInVolume 35636029
 
 #define UIService_LogCode_SetUIState "QLR040230B00"
 #define UIService_LogCode_SendAgentText "QLR040230B01"
@@ -1209,6 +1223,135 @@ struct UIService_StopTransactionRecord_Ans
 
 };
 
+struct UIService_GetCallStatse_Req
+{
+
+	void Serialize(SpBuffer &Buf)
+	{
+	}
+
+};
+
+struct UIService_GetCallStatse_Ans
+{
+	int iState;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & iState;
+	}
+
+};
+
+struct UIService_HangupCall_Info
+{
+
+	void Serialize(SpBuffer &Buf)
+	{
+	}
+
+};
+
+struct UIService_GetTransactionRecordState_Req
+{
+
+	void Serialize(SpBuffer &Buf)
+	{
+	}
+
+};
+
+struct UIService_GetTransactionRecordState_Ans
+{
+	int iRecordState;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & iRecordState;
+	}
+
+};
+
+struct UIService_GetHandfreeInVolume_Req
+{
+
+	void Serialize(SpBuffer &Buf)
+	{
+	}
+
+};
+
+struct UIService_GetHandfreeInVolume_Ans
+{
+	int Volume;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & Volume;
+	}
+
+};
+
+struct UIService_SetHandfreeInVolume_Req
+{
+	int Volume;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & Volume;
+	}
+
+};
+
+struct UIService_SetHandfreeInVolume_Ans
+{
+
+	void Serialize(SpBuffer &Buf)
+	{
+	}
+
+};
+
+struct UIService_GetPickupInVolume_Req
+{
+
+	void Serialize(SpBuffer &Buf)
+	{
+	}
+
+};
+
+struct UIService_GetPickupInVolume_Ans
+{
+	int Volume;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & Volume;
+	}
+
+};
+
+struct UIService_SetPickupInVolume_Req
+{
+	int Volume;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & Volume;
+	}
+
+};
+
+struct UIService_SetPickupInVolume_Ans
+{
+
+	void Serialize(SpBuffer &Buf)
+	{
+	}
+
+};
+
 
 ///////////////////////////
 

Module/mod_interactivecontrol/InteractiveControl_server_g.h

@@ -415,6 +415,55 @@ public:
 				Error = Error_MethodSignatureFailed;
 			}
 			break;
+		case UIService_Method_GetCallStatse:
+			if (dwSignature == UIService_MethodSignature_GetCallStatse) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case UIService_Method_HangupCall:
+			if (dwSignature == UIService_MethodSignature_HangupCall) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case UIService_Method_GetTransactionRecordState:
+			if (dwSignature == UIService_MethodSignature_GetTransactionRecordState) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case UIService_Method_GetHandfreeInVolume:
+			if (dwSignature == UIService_MethodSignature_GetHandfreeInVolume) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case UIService_Method_SetHandfreeInVolume:
+			if (dwSignature == UIService_MethodSignature_SetHandfreeInVolume) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case UIService_Method_GetPickupInVolume:
+			if (dwSignature == UIService_MethodSignature_GetPickupInVolume) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case UIService_Method_SetPickupInVolume:
+			if (dwSignature == UIService_MethodSignature_SetPickupInVolume) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
 		default:
 			Error = Error_MethodNotFound;
 			break;
@@ -701,6 +750,41 @@ public:
 				Error = Error_MethodSignatureFailed;
 			}
 			break;
+		case UIService_Method_GetCallStatse:
+			if (dwSignature != UIService_MethodSignature_GetCallStatse) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case UIService_Method_HangupCall:
+			if (dwSignature != UIService_MethodSignature_HangupCall) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case UIService_Method_GetTransactionRecordState:
+			if (dwSignature != UIService_MethodSignature_GetTransactionRecordState) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case UIService_Method_GetHandfreeInVolume:
+			if (dwSignature != UIService_MethodSignature_GetHandfreeInVolume) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case UIService_Method_SetHandfreeInVolume:
+			if (dwSignature != UIService_MethodSignature_SetHandfreeInVolume) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case UIService_Method_GetPickupInVolume:
+			if (dwSignature != UIService_MethodSignature_GetPickupInVolume) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case UIService_Method_SetPickupInVolume:
+			if (dwSignature != UIService_MethodSignature_SetPickupInVolume) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
 		default:
 			Error = Error_MethodNotFound;
 			break;
@@ -983,6 +1067,41 @@ public:
 	/// override by user
 	}
 
+	virtual void Handle_GetCallStatse(SpReqAnsContext<UIService_GetCallStatse_Req, UIService_GetCallStatse_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_HangupCall(SpOnewayCallContext<UIService_HangupCall_Info>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_GetTransactionRecordState(SpReqAnsContext<UIService_GetTransactionRecordState_Req, UIService_GetTransactionRecordState_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_GetHandfreeInVolume(SpReqAnsContext<UIService_GetHandfreeInVolume_Req, UIService_GetHandfreeInVolume_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_SetHandfreeInVolume(SpReqAnsContext<UIService_SetHandfreeInVolume_Req, UIService_SetHandfreeInVolume_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_GetPickupInVolume(SpReqAnsContext<UIService_GetPickupInVolume_Req, UIService_GetPickupInVolume_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_SetPickupInVolume(SpReqAnsContext<UIService_SetPickupInVolume_Req, UIService_SetPickupInVolume_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
 	virtual void OnRequest(CSmartPointer<ITransactionContext> pTransactionContext)
 	{
 		CAutoBuffer Buf;
@@ -1525,6 +1644,7 @@ public:
 						ctx.Attach(new SpReqAnsContext<UIService_GetRecordMode_Req,UIService_GetRecordMode_Ans>(pTransactionContext));
 						SpBuffer2Object(Buf, ctx->Req);
 						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
 						Handle_GetRecordMode(ctx);
 					}
 					break;
@@ -1534,6 +1654,7 @@ public:
 						ctx.Attach(new SpReqAnsContext<UIService_StartTransactionRecord_Req,UIService_StartTransactionRecord_Ans>(pTransactionContext));
 						SpBuffer2Object(Buf, ctx->Req);
 						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
 						Handle_StartTransactionRecord(ctx);
 					}
 					break;
@@ -1543,9 +1664,80 @@ public:
 						ctx.Attach(new SpReqAnsContext<UIService_StopTransactionRecord_Req,UIService_StopTransactionRecord_Ans>(pTransactionContext));
 						SpBuffer2Object(Buf, ctx->Req);
 						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
 						Handle_StopTransactionRecord(ctx);
 					}
 					break;
+				case UIService_Method_GetCallStatse:
+					{
+						SpReqAnsContext<UIService_GetCallStatse_Req,UIService_GetCallStatse_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<UIService_GetCallStatse_Req,UIService_GetCallStatse_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_GetCallStatse(ctx);
+					}
+					break;
+				case UIService_Method_HangupCall:
+					{
+						SpOnewayCallContext<UIService_HangupCall_Info>::Pointer ctx;
+						ctx.Attach(new SpOnewayCallContext<UIService_HangupCall_Info>());
+						SpBuffer2Object(Buf, ctx->Info);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_HangupCall(ctx);
+					}
+					break;
+				case UIService_Method_GetTransactionRecordState:
+					{
+						SpReqAnsContext<UIService_GetTransactionRecordState_Req,UIService_GetTransactionRecordState_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<UIService_GetTransactionRecordState_Req,UIService_GetTransactionRecordState_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_GetTransactionRecordState(ctx);
+					}
+					break;
+				case UIService_Method_GetHandfreeInVolume:
+					{
+						SpReqAnsContext<UIService_GetHandfreeInVolume_Req,UIService_GetHandfreeInVolume_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<UIService_GetHandfreeInVolume_Req,UIService_GetHandfreeInVolume_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_GetHandfreeInVolume(ctx);
+					}
+					break;
+				case UIService_Method_SetHandfreeInVolume:
+					{
+						SpReqAnsContext<UIService_SetHandfreeInVolume_Req,UIService_SetHandfreeInVolume_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<UIService_SetHandfreeInVolume_Req,UIService_SetHandfreeInVolume_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_SetHandfreeInVolume(ctx);
+					}
+					break;
+				case UIService_Method_GetPickupInVolume:
+					{
+						SpReqAnsContext<UIService_GetPickupInVolume_Req,UIService_GetPickupInVolume_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<UIService_GetPickupInVolume_Req,UIService_GetPickupInVolume_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_GetPickupInVolume(ctx);
+					}
+					break;
+				case UIService_Method_SetPickupInVolume:
+					{
+						SpReqAnsContext<UIService_SetPickupInVolume_Req,UIService_SetPickupInVolume_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<UIService_SetPickupInVolume_Req,UIService_SetPickupInVolume_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_SetPickupInVolume(ctx);
+					}
+					break;
 				default:
 					assert(0);
 					break;

Module/mod_interactivecontrol/mod_interactivecontrol.cpp

@@ -10,8 +10,6 @@
 #define MAX_PATH 260
 #endif
 
-
-
 #include "../mod_sipphone/SIPPhone_client_g.h"
 #include "../mod_sipphone/SIPPhone_def_g.h"
 using namespace SIPPhone;
@@ -33,6 +31,32 @@ struct CRecvValue
 };
 
 
+static int GetCallStateId(const CSimpleStringA strCallState)
+{
+	char* sts[] = {
+		"O", // Offline
+		"C", // Connecting
+		"H", // HandFree
+		"P", // Pickup
+		"B", // Broken
+		"F", // Fail
+		"R", // Releasing
+		"L", // LiveDetect
+		"V"  // Recording
+	};
+
+	int iCallState = 0;
+	for (int i = 0; i < sizeof(sts) / sizeof(char*); i++) {
+		if (0 == strCallState.Compare(sts[i])) {
+			iCallState = i;
+			break;
+		}
+	}
+
+	return iCallState;
+}
+
+
 void CITCtrlEntity::OnAudioPlayRet(const char *pszEntityName, DWORD dwMessageId, DWORD dwMessageSignature, LocalMediaPlay::AudioPlayRet &evt)
 {
 	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("AudioPlayRet %s", (LPCTSTR)evt.AudioNames);
@@ -394,7 +418,7 @@ void CITCtrlEntity::OnSysVarEvent(const char *pszKey, const char *pszValue,const
 				CSimpleStringA strValue;
 				Func->GetSysVar("DesktopType", strValue);
 				if (strValue == CSimpleStringA("U")) {
-				#ifdef _WIN32
+				#ifdef RVC_OS_WIN
 					MessageBoxA(NULL, (LPCSTR)CSimpleStringA::Format("%s摄像头故障！", (strlen(pszValue) <= 1 ? "" : pszValue + 1)), NULL, MB_SYSTEMMODAL);
 				#else
 
@@ -921,7 +945,7 @@ ErrorCodeEnum CITCtrlEntity::SendBusinessDesktopCmd(CSimpleStringA xapName, CSim
 	return Error_Succeed;
 }
 
-ErrorCodeEnum CITCtrlEntity::GetHandfreeCallOutVolume(int& nVolume, DWORD dwTimeout)
+ErrorCodeEnum CITCtrlEntity::GetHandfreeVolume(int iType, int& nVolume, DWORD dwTimeout)
 {
 	auto rc = Error_Succeed;
 
@@ -930,99 +954,120 @@ ErrorCodeEnum CITCtrlEntity::GetHandfreeCallOutVolume(int& nVolume, DWORD dwTime
 	}
 	else
 	{
-		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("pSipPhoneClient connected success!");
-		PhoneService_GetHandfreeOutVolume_Req req;
-		PhoneService_GetHandfreeOutVolume_Ans ans;
-		rc = (*m_pSipPhoneClient)(EntityResource::getLink().upgradeLink())->GetHandfreeOutVolume(req, ans, 1000);
-		nVolume = ans.Volume;
-		if(Error_Succeed == rc)
-		{
-			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("get hand free out volume success.");
+		if (0 == iType) {
+			PhoneService_GetHandfreeInVolume_Req req;
+			PhoneService_GetHandfreeInVolume_Ans ans;
+			rc = (*m_pSipPhoneClient)(EntityResource::getLink().upgradeLink())->GetHandfreeInVolume(req, ans, 1000);
+			nVolume = ans.Volume;
 		}
-		else
-		{
-			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("get hand free out volume failed for 0x%08x", rc);
+		else {
+			PhoneService_GetHandfreeOutVolume_Req req;
+			PhoneService_GetHandfreeOutVolume_Ans ans;
+			rc = (*m_pSipPhoneClient)(EntityResource::getLink().upgradeLink())->GetHandfreeOutVolume(req, ans, 1000);
+			nVolume = ans.Volume;
+		}
+
+		if(Error_Succeed == rc){
+			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("get hand free volume success.");
+		}
+		else{
+			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("get hand free volume failed for 0x%08x", rc);
 		}
 	}
 
 	return rc;
 }
 
-ErrorCodeEnum CITCtrlEntity::SetHandfreeCallOutVolume(int nVolume, DWORD dwTimeout)
+ErrorCodeEnum CITCtrlEntity::SetHandfreeVolume(int iType, int nVolume, DWORD dwTimeout)
 {
 	auto rc = Error_Succeed;
 
 	if (!IsSipPhoneEntityAvailable()) {
 		rc = Error_DevConnFailed;
 	}
-	else
-	{
-		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("pSipPhoneClient connected success!");
-		PhoneService_SetHandfreeOutVolume_Req req;
-		req.Volume = nVolume;
-		PhoneService_SetHandfreeOutVolume_Ans ans;
-		rc = (*m_pSipPhoneClient)(EntityResource::getLink().upgradeLink())->SetHandfreeOutVolume(req, ans, 1000);
-		if(Error_Succeed == rc)
-		{
-			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("set hand free out volume success.");
+	else{
+		if (0 == iType) {
+			PhoneService_SetHandfreeInVolume_Req req;
+			req.Volume = nVolume;
+			PhoneService_SetHandfreeInVolume_Ans ans;
+			rc = (*m_pSipPhoneClient)(EntityResource::getLink().upgradeLink())->SetHandfreeInVolume(req, ans, 1000);
 		}
-		else
-		{
-			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("set hand free out volume failed for 0x%08x", rc);
+		else {
+			PhoneService_SetHandfreeOutVolume_Req req;
+			req.Volume = nVolume;
+			PhoneService_SetHandfreeOutVolume_Ans ans;
+			rc = (*m_pSipPhoneClient)(EntityResource::getLink().upgradeLink())->SetHandfreeOutVolume(req, ans, 1000);
+		}
+
+		if(Error_Succeed == rc){
+			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("set hand free volume success.");
+		}
+		else{
+			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("set hand free volume failed for 0x%08x", rc);
 		}
 	}
 
 	return rc;
 }
 
-ErrorCodeEnum CITCtrlEntity::GetPickupCallOutVolume(int& nVolume, DWORD dwTimeout)
+ErrorCodeEnum CITCtrlEntity::GetPickupVolume(int iType, int& nVolume, DWORD dwTimeout)
 {
 	auto rc = Error_Succeed;
 
 	if (!IsSipPhoneEntityAvailable()) {
 		rc = Error_DevConnFailed;
 	}
-	else
-	{
-		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("pSipPhoneClient connected success!");
-		PhoneService_GetPickupOutVolume_Req req;
-		PhoneService_GetPickupOutVolume_Ans ans;
-		rc = (*m_pSipPhoneClient)(EntityResource::getLink().upgradeLink())->GetPickupOutVolume(req, ans, 1000);
-		nVolume = ans.Volume;
-		if(Error_Succeed == rc)
-		{
-			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("get pickup out volume success.");
+	else{
+		if (0 == iType) {
+			PhoneService_GetPickupInVolume_Req req;
+			PhoneService_GetPickupInVolume_Ans ans;
+			rc = (*m_pSipPhoneClient)(EntityResource::getLink().upgradeLink())->GetPickupInVolume(req, ans, 1000);
+			nVolume = ans.Volume;
 		}
-		else
-		{
-			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("get pickup out volume failed for 0x%08x", rc);
+		else {
+			PhoneService_GetPickupOutVolume_Req req;
+			PhoneService_GetPickupOutVolume_Ans ans;
+			rc = (*m_pSipPhoneClient)(EntityResource::getLink().upgradeLink())->GetPickupOutVolume(req, ans, 1000);
+			nVolume = ans.Volume;
+		}
+
+		if(Error_Succeed == rc){
+			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("get pickup volume success.");
+		}
+		else{
+			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("get pickup volume failed for 0x%08x", rc);
 		}
 	}
 
 	return rc;
 }
 
-ErrorCodeEnum CITCtrlEntity::SetPickupCallOutVolume(int nVolume, DWORD dwTimeout)
+ErrorCodeEnum CITCtrlEntity::SetPickupVolume(int iType, int nVolume, DWORD dwTimeout)
 {
 	auto rc = Error_Succeed;
 
 	if (!IsSipPhoneEntityAvailable()) {
 		rc = Error_DevConnFailed;
 	}
-	else
-	{
-		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("pSipPhoneClient connected success!");
-		PhoneService_SetPickupOutVolume_Req req;
-		req.Volume = nVolume;
-		PhoneService_SetPickupOutVolume_Ans ans;
-		rc = (*m_pSipPhoneClient)(EntityResource::getLink().upgradeLink())->SetPickupOutVolume(req, ans, 1000);
-		if(Error_Succeed == rc)
-		{
-			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("set pickup out volume success.");
+	else{
+		if (0 == iType) {
+			PhoneService_SetPickupInVolume_Req req;
+			req.Volume = nVolume;
+			PhoneService_SetPickupInVolume_Ans ans;
+			rc = (*m_pSipPhoneClient)(EntityResource::getLink().upgradeLink())->SetPickupInVolume(req, ans, 1000);
 		}
-		else
-		{
-			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("set pickup out volume failed for 0x%08x", rc);
+		else {
+			PhoneService_SetPickupOutVolume_Req req;
+			req.Volume = nVolume;
+			PhoneService_SetPickupOutVolume_Ans ans;
+			rc = (*m_pSipPhoneClient)(EntityResource::getLink().upgradeLink())->SetPickupOutVolume(req, ans, 1000);
+		}
+
+		if(Error_Succeed == rc){
+			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("set pickup volume success.");
+		}
+		else{
+			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("set pickup volume failed for 0x%08x", rc);
 		}
 	}
 
@@ -1198,7 +1243,6 @@ ErrorCodeEnum CITCtrlEntity::StartEwsCamera(CSimpleStringA &errMsg)
 ErrorCodeEnum CITCtrlEntity::StopEwsCamera()
 {
 	auto rc = Error_Succeed;
-
 	return rc;
 }
 
@@ -2331,7 +2375,7 @@ void UIServiceSession::Handle_StartPlaySalesRecord(SpReqAnsContext<UIService_Sta
 void UIServiceSession::Handle_GetHandfreeOutVolume(SpReqAnsContext<UIService_GetHandfreeOutVolume_Req, UIService_GetHandfreeOutVolume_Ans>::Pointer ctx)
 {
 	DbgToBeidou(ctx->link, __FUNCTION__)();
-	ErrorCodeEnum Error = m_pEntity->GetHandfreeCallOutVolume(ctx->Ans.Volume, 2000);
+	ErrorCodeEnum Error = m_pEntity->GetHandfreeVolume(1, ctx->Ans.Volume, 2000);
 	ctx->Answer(Error);
 }
 
@@ -2339,7 +2383,7 @@ void UIServiceSession::Handle_GetHandfreeOutVolume(SpReqAnsContext<UIService_Get
 void UIServiceSession::Handle_SetHandfreeOutVolume(SpReqAnsContext<UIService_SetHandfreeOutVolume_Req, UIService_SetHandfreeOutVolume_Ans>::Pointer ctx)
 {
 	DbgToBeidou(ctx->link, __FUNCTION__)();
-	ErrorCodeEnum Error = m_pEntity->SetHandfreeCallOutVolume(ctx->Req.Volume, 2000);
+	ErrorCodeEnum Error = m_pEntity->SetHandfreeVolume(1, ctx->Req.Volume, 2000);
 	ctx->Answer(Error);
 }
 
@@ -2347,7 +2391,7 @@ void UIServiceSession::Handle_SetHandfreeOutVolume(SpReqAnsContext<UIService_Set
 void UIServiceSession::Handle_GetPickupOutVolume(SpReqAnsContext<UIService_GetPickupOutVolume_Req, UIService_GetPickupOutVolume_Ans>::Pointer ctx)
 {
 	DbgToBeidou(ctx->link, __FUNCTION__)();
-	ErrorCodeEnum Error = m_pEntity->GetPickupCallOutVolume(ctx->Ans.Volume, 2000);
+	ErrorCodeEnum Error = m_pEntity->GetPickupVolume(1, ctx->Ans.Volume, 2000);
 	ctx->Answer(Error);
 }
 
@@ -2355,7 +2399,7 @@ void UIServiceSession::Handle_GetPickupOutVolume(SpReqAnsContext<UIService_GetPi
 void UIServiceSession::Handle_SetPickupOutVolume(SpReqAnsContext<UIService_SetPickupOutVolume_Req, UIService_SetPickupOutVolume_Ans>::Pointer ctx)
 {
 	DbgToBeidou(ctx->link, __FUNCTION__)();
-	ErrorCodeEnum Error = m_pEntity->SetPickupCallOutVolume(ctx->Req.Volume, 2000);
+	ErrorCodeEnum Error = m_pEntity->SetPickupVolume(1, ctx->Req.Volume, 2000);
 	ctx->Answer(Error);
 }
 
@@ -2502,6 +2546,69 @@ void UIServiceSession::Handle_StopTransactionRecord(SpReqAnsContext<UIService_St
 }
 
 
+void UIServiceSession::Handle_GetCallStatse(SpReqAnsContext<UIService_GetCallStatse_Req, UIService_GetCallStatse_Ans>::Pointer ctx)
+{
+	DbgToBeidou(ctx->link, __FUNCTION__)();
+
+	CSimpleStringA strCallState("");
+	ErrorCodeEnum errorCode = m_pEntity->GetFunction()->GetSysVar("CallState", strCallState);
+	if (Error_Succeed == errorCode) {
+		ctx->Ans.iState = GetCallStateId(strCallState);
+		ctx->Answer(Error_Succeed);
+	}
+	else {
+		ctx->Answer(Error_Unexpect);
+	}
+}
+
+void UIServiceSession::Handle_HangupCall(SpOnewayCallContext<UIService_HangupCall_Info>::Pointer ctx)
+{
+	DbgToBeidou(ctx->link, __FUNCTION__)();
+}
+
+void UIServiceSession::Handle_GetTransactionRecordState(SpReqAnsContext<UIService_GetTransactionRecordState_Req, UIService_GetTransactionRecordState_Ans>::Pointer ctx)
+{
+	DbgToBeidou(ctx->link, __FUNCTION__)();
+
+	if (m_pEntity->m_bRecording) {
+		ctx->Ans.iRecordState = 1;
+	}
+	else {
+		ctx->Ans.iRecordState = 0;
+	}
+
+	ctx->Answer(Error_Succeed);
+}
+
+void UIServiceSession::Handle_GetHandfreeInVolume(SpReqAnsContext<UIService_GetHandfreeInVolume_Req, UIService_GetHandfreeInVolume_Ans>::Pointer ctx)
+{
+	DbgToBeidou(ctx->link, __FUNCTION__)();
+	ErrorCodeEnum Error = m_pEntity->GetHandfreeVolume(0, ctx->Ans.Volume, 2000);
+	ctx->Answer(Error);
+}
+
+void UIServiceSession::Handle_SetHandfreeInVolume(SpReqAnsContext<UIService_SetHandfreeInVolume_Req, UIService_SetHandfreeInVolume_Ans>::Pointer ctx)
+{
+	DbgToBeidou(ctx->link, __FUNCTION__)();
+	ErrorCodeEnum Error = m_pEntity->SetHandfreeVolume(0, ctx->Req.Volume, 2000);
+	ctx->Answer(Error);
+}
+
+void UIServiceSession::Handle_GetPickupInVolume(SpReqAnsContext<UIService_GetPickupInVolume_Req, UIService_GetPickupInVolume_Ans>::Pointer ctx)
+{
+	DbgToBeidou(ctx->link, __FUNCTION__)();
+	ErrorCodeEnum Error = m_pEntity->GetPickupVolume(0, ctx->Ans.Volume, 2000);
+	ctx->Answer(Error);
+}
+
+void UIServiceSession::Handle_SetPickupInVolume(SpReqAnsContext<UIService_SetPickupInVolume_Req, UIService_SetPickupInVolume_Ans>::Pointer ctx)
+{
+	DbgToBeidou(ctx->link, __FUNCTION__)();
+	ErrorCodeEnum Error = m_pEntity->SetPickupVolume(0, ctx->Req.Volume, 2000);
+	ctx->Answer(Error);
+}
+
+
 ChannelClient::ChannelClient( CITCtrlEntity *pEntity ) : ChannelService_ClientBase(pEntity)
 {
 

Module/mod_interactivecontrol/mod_interactivecontrol.h

@@ -166,13 +166,13 @@ public:
 
 	ErrorCodeEnum SendBusinessDesktopCmd(CSimpleStringA xapName, CSimpleStringA command);
 
-	ErrorCodeEnum GetHandfreeCallOutVolume(int& nVolume, DWORD dwTimeout);
+	ErrorCodeEnum GetHandfreeVolume(int iType, int& nVolume, DWORD dwTimeout);
 
-	ErrorCodeEnum SetHandfreeCallOutVolume(int nVolume, DWORD dwTimeout);
+	ErrorCodeEnum SetHandfreeVolume(int iType, int nVolume, DWORD dwTimeout);
 
-	ErrorCodeEnum GetPickupCallOutVolume(int& nVolume, DWORD dwTimeout);
+	ErrorCodeEnum GetPickupVolume(int iType, int& nVolume, DWORD dwTimeout);
 
-	ErrorCodeEnum SetPickupCallOutVolume(int nVolume, DWORD dwTimeout);
+	ErrorCodeEnum SetPickupVolume(int iType, int nVolume, DWORD dwTimeout);
 
 	void OnLog(const CAutoArray<CUUID> &SubIDs, const CUUID nLogID,const LogTypeEnum eLogType, const SeverityLevelEnum eLevel,
 		const DWORD dwSysError,const DWORD dwUserCode,const DWORD dwEntityInstanceID, const WORD wEntityDevelID, 
@@ -413,7 +413,20 @@ public:
 	virtual void Handle_StartTransactionRecord(SpReqAnsContext<UIService_StartTransactionRecord_Req, UIService_StartTransactionRecord_Ans>::Pointer ctx);
 
 	virtual void Handle_StopTransactionRecord(SpReqAnsContext<UIService_StopTransactionRecord_Req, UIService_StopTransactionRecord_Ans>::Pointer ctx);
-	
+
+	virtual void Handle_GetCallStatse(SpReqAnsContext<UIService_GetCallStatse_Req, UIService_GetCallStatse_Ans>::Pointer ctx);
+
+	virtual void Handle_HangupCall(SpOnewayCallContext<UIService_HangupCall_Info>::Pointer ctx);
+
+	virtual void Handle_GetTransactionRecordState(SpReqAnsContext<UIService_GetTransactionRecordState_Req, UIService_GetTransactionRecordState_Ans>::Pointer ctx);
+
+	virtual void Handle_GetHandfreeInVolume(SpReqAnsContext<UIService_GetHandfreeInVolume_Req, UIService_GetHandfreeInVolume_Ans>::Pointer ctx);
+
+	virtual void Handle_SetHandfreeInVolume(SpReqAnsContext<UIService_SetHandfreeInVolume_Req, UIService_SetHandfreeInVolume_Ans>::Pointer ctx);
+
+	virtual void Handle_GetPickupInVolume(SpReqAnsContext<UIService_GetPickupInVolume_Req, UIService_GetPickupInVolume_Ans>::Pointer ctx);
+
+	virtual void Handle_SetPickupInVolume(SpReqAnsContext<UIService_SetPickupInVolume_Req, UIService_SetPickupInVolume_Ans>::Pointer ctx);
 
 private:
 	CITCtrlEntity *m_pEntity;

Module/mod_sipphone/Event.h

@@ -191,13 +191,10 @@
 #define CALLTYPE_NORMAL 'N' // 呼叫类型，普通模式
 #define CALLTYPE_MOBILE	'M' // 呼叫类型，手机模式
 	
+#define LOG_EVT_UI_STARTRECORD					0x30B00001				//开始录像
+#define LOG_EVT_UI_STOPRECORD					0x30B00002				//停止录像
+#define LOG_EVT_UI_RETURNMENU					0x30B00006				//退出到主菜单
 
-//event add by ly@20180725
-#define LOG_EVT_UI_STARTRECORD		0x30B00001				//开始录像
-#define LOG_EVT_UI_STOPRECORD		0x30B00002				//停止录像
-#define LOG_EVT_UI_RETURNMENU		0x30B00006				//退出到主菜单
-
-// add by clp  20191106
 #define LOG_EVT_UI_STARTREMOTERECORD			0x30B0000F				//开始远程双录
 #define LOG_EVT_UI_STOPREMOTERECORD				0x30B00018				//停止远程录像
 

Module/mod_sipphone/SIPPhone_client_g.h

@@ -519,6 +519,202 @@ public:
 		return ret;
 	}
 
+	ErrorCodeEnum GetHandfreeInVolume(PhoneService_GetHandfreeInVolume_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(PhoneService_Method_GetHandfreeInVolume, PhoneService_MethodSignature_GetHandfreeInVolume, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum GetHandfreeInVolume(PhoneService_GetHandfreeInVolume_Req &Req, PhoneService_GetHandfreeInVolume_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = GetHandfreeInVolume(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum GetHandfreeInVolume(PhoneService_GetHandfreeInVolume_Req &Req, PhoneService_GetHandfreeInVolume_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = GetHandfreeInVolume(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum GetHandfreeInVolume(PhoneService_GetHandfreeInVolume_Req &Req, PhoneService_GetHandfreeInVolume_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = GetHandfreeInVolume(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum SetHandfreeInVolume(PhoneService_SetHandfreeInVolume_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(PhoneService_Method_SetHandfreeInVolume, PhoneService_MethodSignature_SetHandfreeInVolume, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum SetHandfreeInVolume(PhoneService_SetHandfreeInVolume_Req &Req, PhoneService_SetHandfreeInVolume_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = SetHandfreeInVolume(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum SetHandfreeInVolume(PhoneService_SetHandfreeInVolume_Req &Req, PhoneService_SetHandfreeInVolume_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = SetHandfreeInVolume(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum SetHandfreeInVolume(PhoneService_SetHandfreeInVolume_Req &Req, PhoneService_SetHandfreeInVolume_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = SetHandfreeInVolume(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum SetPickupInVolume(PhoneService_SetPickupInVolume_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(PhoneService_Method_SetPickupInVolume, PhoneService_MethodSignature_SetPickupInVolume, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum SetPickupInVolume(PhoneService_SetPickupInVolume_Req &Req, PhoneService_SetPickupInVolume_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = SetPickupInVolume(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum SetPickupInVolume(PhoneService_SetPickupInVolume_Req &Req, PhoneService_SetPickupInVolume_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = SetPickupInVolume(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum SetPickupInVolume(PhoneService_SetPickupInVolume_Req &Req, PhoneService_SetPickupInVolume_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = SetPickupInVolume(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
+	ErrorCodeEnum GetPickupInVolume(PhoneService_GetPickupInVolume_Req &Req, CSmartPointer<IAsynWaitSp> &spAsyncWait, DWORD dwTimeout)
+	{
+		CSmartPointer<IClientSessionFunction> pFunc = GetFunction();
+		CAutoBuffer Buf = SpObject2Buffer(Req);
+		if (m_context.checkEmpty())
+		{
+			m_context.AutoGenerate();
+			DbgToBeidou(m_context, m_pEntityBase != NULL ? m_pEntityBase->GetEntityName() : "")();
+			m_context = m_context.upgradeLink();
+		}
+		auto ret = pFunc->AsyncRequest(PhoneService_Method_GetPickupInVolume, PhoneService_MethodSignature_GetPickupInVolume, Buf, spAsyncWait, m_context, dwTimeout);
+		m_context.clear();
+		return ret;
+	}
+	ErrorCodeEnum GetPickupInVolume(PhoneService_GetPickupInVolume_Req &Req, PhoneService_GetPickupInVolume_Ans &Ans, DWORD dwTimeout)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = GetPickupInVolume(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum GetPickupInVolume(PhoneService_GetPickupInVolume_Req &Req, PhoneService_GetPickupInVolume_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError, CSimpleString &str)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = GetPickupInVolume(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+	ErrorCodeEnum GetPickupInVolume(PhoneService_GetPickupInVolume_Req &Req, PhoneService_GetPickupInVolume_Ans &Ans, DWORD dwTimeout, DWORD &dwUserError)
+	{
+		CSmartPointer<IAsynWaitSp> spAsyncWait;
+		ErrorCodeEnum Error = GetPickupInVolume(Req, spAsyncWait, dwTimeout);
+		if (Error == Error_Succeed) {
+			bool bEnd = false;
+			CSimpleString str;
+			Error = SpWaitAnswerObject(spAsyncWait, Ans, bEnd, dwUserError, str, dwTimeout);
+			LOG_ASSERT(Error || bEnd);
+		}
+		return Error;
+	}
+
 
 	bool SafeDelete()
 	{

Module/mod_sipphone/SIPPhone_def_g.h

@@ -35,6 +35,10 @@ namespace SIPPhone {
 #define PhoneService_Method_GetPickupOutVolume 13
 #define PhoneService_Method_StartVideoRender 14
 #define PhoneService_Method_StopVideoRender 15
+#define PhoneService_Method_GetHandfreeInVolume 16
+#define PhoneService_Method_SetHandfreeInVolume 17
+#define PhoneService_Method_SetPickupInVolume 18
+#define PhoneService_Method_GetPickupInVolume 19
 
 #define PhoneService_MethodSignature_MakeCall -1045574280
 #define PhoneService_MethodSignature_HangupCall 507892508
@@ -52,6 +56,24 @@ namespace SIPPhone {
 #define PhoneService_MethodSignature_GetPickupOutVolume 1201465844
 #define PhoneService_MethodSignature_StartVideoRender 1914738730
 #define PhoneService_MethodSignature_StopVideoRender -1920889093
+#define PhoneService_MethodSignature_GetHandfreeInVolume -973146972
+#define PhoneService_MethodSignature_SetHandfreeInVolume -1471315400
+#define PhoneService_MethodSignature_SetPickupInVolume 35636029
+#define PhoneService_MethodSignature_GetPickupInVolume -735373015
+
+#define PhoneService_LogCode_MakeCall "QLR040230100"
+#define PhoneService_LogCode_HangupCall "QLR040230101"
+#define PhoneService_LogCode_StartVideo "QLR040230102"
+#define PhoneService_LogCode_StopVideo "QLR040230103"
+#define PhoneService_LogCode_RealErrorCheck "QLR040230104"
+#define PhoneService_LogCode_ReleaseCall "QLR040230105"
+#define PhoneService_LogCode_SetCallingParam "QLR040230109"
+#define PhoneService_LogCode_GetHandfreeOutVolume "QLR040230110"
+#define PhoneService_LogCode_SetHandfreeOutVolume "QLR040230111"
+#define PhoneService_LogCode_SetPickupOutVolume "QLR040230112"
+#define PhoneService_LogCode_GetPickupOutVolume "QLR040230113"
+#define PhoneService_LogCode_StartVideoRender "QLR040230114"
+#define PhoneService_LogCode_StopVideoRender "QLR040230115"
 
 struct PhoneService_MakeCall_Req
 {
@@ -313,6 +335,86 @@ struct PhoneService_StopVideoRender_Info
 
 };
 
+struct PhoneService_GetHandfreeInVolume_Req
+{
+
+	void Serialize(SpBuffer &Buf)
+	{
+	}
+
+};
+
+struct PhoneService_GetHandfreeInVolume_Ans
+{
+	int Volume;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & Volume;
+	}
+
+};
+
+struct PhoneService_SetHandfreeInVolume_Req
+{
+	int Volume;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & Volume;
+	}
+
+};
+
+struct PhoneService_SetHandfreeInVolume_Ans
+{
+
+	void Serialize(SpBuffer &Buf)
+	{
+	}
+
+};
+
+struct PhoneService_SetPickupInVolume_Req
+{
+	int Volume;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & Volume;
+	}
+
+};
+
+struct PhoneService_SetPickupInVolume_Ans
+{
+
+	void Serialize(SpBuffer &Buf)
+	{
+	}
+
+};
+
+struct PhoneService_GetPickupInVolume_Req
+{
+
+	void Serialize(SpBuffer &Buf)
+	{
+	}
+
+};
+
+struct PhoneService_GetPickupInVolume_Ans
+{
+	int Volume;
+
+	void Serialize(SpBuffer &Buf)
+	{
+		auto & buf = Buf & Volume;
+	}
+
+};
+
 
 ///////////////////////////
 

Module/mod_sipphone/SIPPhone_server_g.h

@@ -135,6 +135,34 @@ public:
 				Error = Error_MethodSignatureFailed;
 			}
 			break;
+		case PhoneService_Method_GetHandfreeInVolume:
+			if (dwSignature == PhoneService_MethodSignature_GetHandfreeInVolume) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case PhoneService_Method_SetHandfreeInVolume:
+			if (dwSignature == PhoneService_MethodSignature_SetHandfreeInVolume) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case PhoneService_Method_SetPickupInVolume:
+			if (dwSignature == PhoneService_MethodSignature_SetPickupInVolume) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case PhoneService_Method_GetPickupInVolume:
+			if (dwSignature == PhoneService_MethodSignature_GetPickupInVolume) {
+				bOverlap = true;
+			} else {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
 		default:
 			Error = Error_MethodNotFound;
 			break;
@@ -221,6 +249,26 @@ public:
 				Error = Error_MethodSignatureFailed;
 			}
 			break;
+		case PhoneService_Method_GetHandfreeInVolume:
+			if (dwSignature != PhoneService_MethodSignature_GetHandfreeInVolume) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case PhoneService_Method_SetHandfreeInVolume:
+			if (dwSignature != PhoneService_MethodSignature_SetHandfreeInVolume) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case PhoneService_Method_SetPickupInVolume:
+			if (dwSignature != PhoneService_MethodSignature_SetPickupInVolume) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
+		case PhoneService_Method_GetPickupInVolume:
+			if (dwSignature != PhoneService_MethodSignature_GetPickupInVolume) {
+				Error = Error_MethodSignatureFailed;
+			}
+			break;
 		default:
 			Error = Error_MethodNotFound;
 			break;
@@ -303,6 +351,26 @@ public:
 	/// override by user
 	}
 
+	virtual void Handle_GetHandfreeInVolume(SpReqAnsContext<PhoneService_GetHandfreeInVolume_Req, PhoneService_GetHandfreeInVolume_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_SetHandfreeInVolume(SpReqAnsContext<PhoneService_SetHandfreeInVolume_Req, PhoneService_SetHandfreeInVolume_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_SetPickupInVolume(SpReqAnsContext<PhoneService_SetPickupInVolume_Req, PhoneService_SetPickupInVolume_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
+	virtual void Handle_GetPickupInVolume(SpReqAnsContext<PhoneService_GetPickupInVolume_Req, PhoneService_GetPickupInVolume_Ans>::Pointer ctx)
+	{
+	/// override by user
+	}
+
 	virtual void OnRequest(CSmartPointer<ITransactionContext> pTransactionContext)
 	{
 		CAutoBuffer Buf;
@@ -465,6 +533,46 @@ public:
 						Handle_StopVideoRender(ctx);
 					}
 					break;
+				case PhoneService_Method_GetHandfreeInVolume:
+					{
+						SpReqAnsContext<PhoneService_GetHandfreeInVolume_Req,PhoneService_GetHandfreeInVolume_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<PhoneService_GetHandfreeInVolume_Req,PhoneService_GetHandfreeInVolume_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_GetHandfreeInVolume(ctx);
+					}
+					break;
+				case PhoneService_Method_SetHandfreeInVolume:
+					{
+						SpReqAnsContext<PhoneService_SetHandfreeInVolume_Req,PhoneService_SetHandfreeInVolume_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<PhoneService_SetHandfreeInVolume_Req,PhoneService_SetHandfreeInVolume_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_SetHandfreeInVolume(ctx);
+					}
+					break;
+				case PhoneService_Method_SetPickupInVolume:
+					{
+						SpReqAnsContext<PhoneService_SetPickupInVolume_Req,PhoneService_SetPickupInVolume_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<PhoneService_SetPickupInVolume_Req,PhoneService_SetPickupInVolume_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_SetPickupInVolume(ctx);
+					}
+					break;
+				case PhoneService_Method_GetPickupInVolume:
+					{
+						SpReqAnsContext<PhoneService_GetPickupInVolume_Req,PhoneService_GetPickupInVolume_Ans>::Pointer ctx;
+						ctx.Attach(new SpReqAnsContext<PhoneService_GetPickupInVolume_Req,PhoneService_GetPickupInVolume_Ans>(pTransactionContext));
+						SpBuffer2Object(Buf, ctx->Req);
+						pTransactionContext->GetLinkContext(ctx->link);
+						EntityResource::setLink(ctx->link);
+						Handle_GetPickupInVolume(ctx);
+					}
+					break;
 				default:
 					assert(0);
 					break;

Module/mod_sipphone/SipService.xml

@@ -104,6 +104,34 @@
 		</oneway>
 		<oneway name="StopVideoRender" overlap="true">
 		</oneway>
+		<twoway name="GetHandfreeInVolume" overlap="true">
+			<req>
+			</req>
+			<res>
+				<param name="Volume" type="int"/>
+			</res>
+		</twoway>
+		<twoway name="SetHandfreeInVolume" overlap="true">
+			<req>
+				<param name="Volume" type="int"/>
+			</req>
+			<res>
+			</res>
+		</twoway>
+		<twoway name="SetPickupInVolume" overlap="true">
+			<req>
+				<param name="Volume" type="int"/>
+			</req>
+			<res>
+			</res>
+		</twoway>
+		<twoway name="GetPickupInVolume" overlap="true">
+			<req>
+			</req>
+			<res>
+				<param name="Volume" type="int"/>
+			</res>
+		</twoway>
 	</class>
 	<!-- ÊÓƵ¿ò¿ªÊ¼Òƶ¯ÏûÏ¢ -->
 	<message name="VideoBoxStartMove">

Module/mod_sipphone/mod_sipphone.h

@@ -189,6 +189,10 @@ public:
 	virtual void Handle_SetPickupOutVolume(SpReqAnsContext<PhoneService_SetPickupOutVolume_Req, PhoneService_SetPickupOutVolume_Ans>::Pointer ctx);
 	virtual void Handle_StartVideoRender(SpOnewayCallContext<PhoneService_StartVideoRender_Info>::Pointer ctx);
 	virtual void Handle_StopVideoRender(SpOnewayCallContext<PhoneService_StopVideoRender_Info>::Pointer ctx);
+	virtual void Handle_GetHandfreeInVolume(SpReqAnsContext<PhoneService_GetHandfreeInVolume_Req, PhoneService_GetHandfreeInVolume_Ans>::Pointer ctx);
+	virtual void Handle_SetHandfreeInVolume(SpReqAnsContext<PhoneService_SetHandfreeInVolume_Req, PhoneService_SetHandfreeInVolume_Ans>::Pointer ctx);
+	virtual void Handle_SetPickupInVolume(SpReqAnsContext<PhoneService_SetPickupInVolume_Req, PhoneService_SetPickupInVolume_Ans>::Pointer ctx);
+	virtual void Handle_GetPickupInVolume(SpReqAnsContext<PhoneService_GetPickupInVolume_Req, PhoneService_GetPickupInVolume_Ans>::Pointer ctx);
 
 public:
 	void on_call_state(int state, const char *state_desc, const char *phrase);
@@ -236,6 +240,8 @@ public:
 	void SendAudioDeviceVolumn(int nDevice);
 	ErrorCodeEnum SetHandfreeOutVolume(int iVolume);
 	ErrorCodeEnum SetPickupOutVolume(int iVolume);
+	ErrorCodeEnum SetHandfreeInVolume(int iVolume);
+	ErrorCodeEnum SetPickupInVolume(int iVolume);
 
 	virtual void OnPreClose(EntityCloseCauseEnum eCloseCause,CSmartPointer<ITransactionContext> pTransactionContext);
 	ErrorCodeEnum __OnClose(ErrorCodeEnum preOperationError);
@@ -293,7 +299,7 @@ public:
 #endif
 	//int m_nDownDynamicFps;	//当前视频下行的帧频，由前端通知后端更改频率,只有移动版才使用
 	CSystemStaticInfo staticInfo;
-	char m_localip[256];		//本地ip
+	char m_localip[RVC_MAX_IP_LEN];		//本地ip
 	endpoint_conf_t conf;
 	endpoint_t *m_pEndpoint;
 	int m_iPickupPhoneState;