SOUI新组件SIpcObject介绍

SIpcObject是一个基于Windows消息及共享内存的一个IPC（跨进程函数调用）的组件。

GITHUB上有很多IPC模块，我这里又造了一个轮子，不一定比现有的IPC更好，不过我觉得已经足够简单了。

老规矩，先看一下IPC模块的路径：

再看一下IPC模块的接口：

 #pragma once

 #include <unknown/obj-ref-i.h>

 #define UM_CALL_FUN (WM_USER+1000)

 namespace SOUI
 {
     enum {
         FUN_ID_CONNECT = ,
         FUN_ID_DISCONNECT,
         FUN_ID_START,
     };

     struct IShareBuffer {
         virtual void StartRead() = ;
         virtual void StartWrite() = ;
         virtual int Write(const void * data, UINT nLen) = ;
         virtual int Read(void * buf, UINT nLen) = ;
     };

     class SParamStream
     {
     public:
         SParamStream(IShareBuffer *pBuf, bool bOutStream) :m_pBuffer(pBuf)
         {
             m_pBuffer->StartRead();
             if (bOutStream) m_pBuffer->StartWrite();
         }

         IShareBuffer * GetBuffer() {
             return m_pBuffer;
         }

         template<typename T>
         SParamStream & operator<<(const T & data)
         {
             Write((const void*)&data, sizeof(data));
             return *this;
         }

         template<typename T>
         SParamStream & operator >> (T &data)
         {
             Read((void*)&data, sizeof(data));
             return *this;
         }

     public:
         int Write(const void * data, int nLen)
         {
             return m_pBuffer->Write(data, nLen);
         }
         int Read(void * buf, int nLen)
         {
             return m_pBuffer->Read(buf, nLen);
         }

     protected:
         IShareBuffer * m_pBuffer;
     };

     struct  IFunParams
     {
         virtual UINT GetID() = ;
         virtual void ToStream4Input(SParamStream &  ps) = ;
         virtual void ToStream4Output(SParamStream &  ps) = ;
         virtual void FromStream4Input(SParamStream &  ps) = ;
         virtual void FromStream4Output(SParamStream &  ps) = ;
     };

     struct IIpcConnection;
     struct IIpcHandle : IObjRef
     {
         virtual void SetIpcConnection(IIpcConnection *pConn) = ;

         virtual IIpcConnection * GetIpcConnection() const = ;

         virtual LRESULT OnMessage(ULONG_PTR idLocal, UINT uMsg, WPARAM wp, LPARAM lp, BOOL &bHandled) = ;

         virtual HRESULT ConnectTo(ULONG_PTR idLocal, ULONG_PTR idRemote) = ;

         virtual HRESULT Disconnect() = ;

         virtual bool CallFun(IFunParams * pParam) const = ;

         virtual ULONG_PTR GetLocalId() const = ;

         virtual ULONG_PTR GetRemoteId() const = ;

         virtual IShareBuffer * GetSendBuffer()  = ;

         virtual IShareBuffer * GetRecvBuffer()  = ;

         virtual BOOL InitShareBuf(ULONG_PTR idLocal, ULONG_PTR idRemote, UINT nBufSize, void* pSa) = ;
     };

     struct IIpcConnection : IObjRef
     {
         virtual IIpcHandle * GetIpcHandle() = ;
         virtual bool HandleFun(UINT uFunID, SParamStream & ps) = ;
         virtual void BuildShareBufferName(ULONG_PTR idLocal, ULONG_PTR idRemote, TCHAR szBuf[MAX_PATH]) const = ;
     };

     struct IIpcSvrCallback
     {
         virtual void OnNewConnection(IIpcHandle * pIpcHandle, IIpcConnection ** ppConn) = ;
         virtual int GetBufSize() const = ;
         virtual void * GetSecurityAttr() const = ;
         virtual void ReleaseSecurityAttr(void* psa) const = ;
     };

     struct IIpcServer : IObjRef
     {
         virtual HRESULT Init(ULONG_PTR idSvr, IIpcSvrCallback * pCallback) =;
         virtual void CheckConnectivity() =;
         virtual LRESULT OnMessage(ULONG_PTR idLocal, UINT uMsg, WPARAM wp, LPARAM lp,BOOL &bHandled) =;
     };

     struct IIpcFactory : IObjRef
     {
         virtual HRESULT CreateIpcServer(IIpcServer ** ppServer) =;
         virtual HRESULT CreateIpcHandle(IIpcHandle ** ppHandle) =;
     };

 }

和所有SOUI的组件一样，可以通过SOUI::IPC::SCreateInstance来创建IPC组件的IIpcFactory接口。

有了这个接口就可以用来创建IIpcServer和IIpcHandle这两个对象了。

IIpcServer是在IPC的服务端运行的接口，IIpcHandle是用来在服务端和客户端通讯的接口，在服务端，IIpcHandle由IIpcServer在客户端发起连接请求时自动创建，在客户端则直接使用IIpcFactory创建。

IIpcHandle是由SIpcObject实现的，在应用层中只需要直接使用。

应用层为了实现客户端与服务器的通讯还需要定义好协议。

SIpcObject的协议就是一个继承自IFunParam接口的定义的调用方法ID及方法参数。

下面看一下启程输入法使用IpcObject的协议定义。

 #pragma once
 #include <string>
 #include <sstream>
 #include "sinstar-i.h"
 #include "TextService-i.h"
 #include <interface/SIpcObj-i.h>
 #include <helper/sipcparamhelper.hpp>

 #define SINSTAR3_SERVER_HWND _T("sinstar3_server_wnd_{85B55CBC-7D48-4860-BA88-0BE4B073A94F}")
 #define SINSTAR3_SHARE_BUF_NAME_FMT _T("sistart3_share_buffer_8085395F-E2FA-4F96-8BD0-FE5D7412CD22_%08x_2_%08x")

 //////////////////////////////////////////////////////////////////
 namespace SOUI{

 template<>
 inline SParamStream & SParamStream::operator<<(const std::string & str)
 {
     int nSize = (int)str.size();
     GetBuffer()->Write((const BYTE*)&nSize, sizeof(int));
     GetBuffer()->Write((const BYTE*)str.c_str(), nSize);
     return *this;
 }
 template<>
 inline SParamStream & SParamStream::operator >> (std::string & str)
 {
     int nSize = ;
     GetBuffer()->Read((BYTE*)&nSize, sizeof(int));
     char *pBuf = new char[nSize];
     GetBuffer()->Read((BYTE*)pBuf, nSize);
     str = std::string(pBuf, nSize);
     delete[]pBuf;
     return *this;
 }

 ////////////////////////////////////////////////////////////////////////
 template<>
 inline SParamStream & SParamStream::operator<<(const std::wstring & str)
 {
     int nSize = (int)str.size();
     GetBuffer()->Write((const BYTE*)&nSize, sizeof(int));
     GetBuffer()->Write((const BYTE*)str.c_str(), nSize*sizeof(wchar_t));
     return *this;
 }
 template<>
 inline SParamStream & SParamStream::operator >> (std::wstring & str)
 {
     int nSize = ;
     GetBuffer()->Read((BYTE*)&nSize, sizeof(int));
     wchar_t *pBuf = new wchar_t[nSize];
     GetBuffer()->Read((BYTE*)pBuf, nSize*sizeof(wchar_t));
     str = std::wstring(pBuf, nSize);
     delete[]pBuf;
     return *this;
 }

 //////////////////////////////////////////////////////////////////////
 template<>
 inline SParamStream & SParamStream::operator<<(const POINT & pt)
 {
     GetBuffer()->Write((const BYTE*)&pt.x, sizeof(int));
     GetBuffer()->Write((const BYTE*)&pt.y, sizeof(int));
     return *this;
 }
 template<>
 inline SParamStream & SParamStream::operator >> (POINT & pt)
 {
     int tmp = ;
     GetBuffer()->Read((BYTE*)&tmp, sizeof(int));
     pt.x = tmp;
     GetBuffer()->Read((BYTE*)&tmp, sizeof(int));
     pt.y = tmp;
     return *this;
 }

 }

 struct FunParams_Base : SOUI::IFunParams
 {
     virtual void ToStream4Input(SOUI::SParamStream &  ps) {}
     virtual void ToStream4Output(SOUI::SParamStream &  ps) {}
     virtual void FromStream4Input(SOUI::SParamStream &  ps) {}
     virtual void FromStream4Output(SOUI::SParamStream &  ps) {}
 };

 enum {
     ISinstar_Create = SOUI::FUN_ID_START,
     ISinstar_Destroy,
     ISinstar_OnImeSelect,
     ISinstar_OnCompositionStarted,
     ISinstar_OnCompositionChanged,
     ISinstar_OnCompositionTerminated,
     ISinstar_OnSetCaretPosition,
     ISinstar_OnSetFocusSegmentPosition,
     ISinstar_ProcessKeyStoke,
     ISinstar_TranslateKey,
     ISinstar_OnSetFocus,
     ISinstar_GetCompositionSegments,
     ISinstar_GetCompositionSegmentEnd,
     ISinstar_GetCompositionSegmentAttr,
     ISinstar_OnOpenStatusChanged,
     ISinstar_OnConversionModeChanged,
     ISinstar_ShowHelp,
     ISinstar_GetDefInputMode,

     ITextService_InputStringW = ISinstar_GetDefInputMode + ,
     ITextService_IsCompositing,
     ITextService_StartComposition,
     ITextService_ReplaceSelCompositionW,
     ITextService_UpdateResultAndCompositionStringW,
     ITextService_EndComposition,
     ITextService_GetImeContext,
     ITextService_ReleaseImeContext,
     ITextService_SetConversionMode,
     ITextService_GetConversionMode,
     ITextService_SetOpenStatus,
     ITextService_GetOpenStatus,
     ITextService_GetActiveWnd,
 };

 struct Param_Create : FunParams_Base
 {
     bool   bDpiAware;
     std::string strHostPath;
     DWORD  dwVer;
     FUNID(ISinstar_Create)
         PARAMS3(Input, bDpiAware,strHostPath,dwVer)
 };

 struct Param_Destroy : FunParams_Base
 {
     FUNID(ISinstar_Destroy)
 };

 struct Param_OnImeSelect : FunParams_Base
 {
     BOOL bSelect;
     FUNID(ISinstar_OnImeSelect)
     PARAMS1(Input, bSelect)
 };

 struct Param_OnCompositionStarted : FunParams_Base
 {
     FUNID(ISinstar_OnCompositionStarted)
 };

 struct Param_OnCompositionTerminated : FunParams_Base
 {
     bool bClearCtx;
     FUNID(ISinstar_OnCompositionTerminated)
     PARAMS1(Input, bClearCtx)
 };

 struct Param_OnCompositionChanged : FunParams_Base
 {
     FUNID(ISinstar_OnCompositionChanged)
 };

 struct Param_OnSetCaretPosition : FunParams_Base
 {
     POINT pt;
     int nHei;
     FUNID(ISinstar_OnSetCaretPosition)
     PARAMS2(Input, pt,nHei)
 };

 struct Param_OnSetFocusSegmentPosition : FunParams_Base
 {
     POINT pt; int nHei;
     FUNID(ISinstar_OnSetFocusSegmentPosition)
     PARAMS2(Input, pt, nHei)
 };

 struct Param_ProcessKeyStoke : FunParams_Base {
     UINT64 lpImeContext; UINT vkCode; DWORD lParam; BOOL bKeyDown;
     BYTE byKeyState[];
     BOOL bEaten;
     FUNID(ISinstar_ProcessKeyStoke)
     PARAMS5(Input, lpImeContext, vkCode, lParam, bKeyDown, byKeyState)
     PARAMS1(Output,bEaten)
 };

 struct Param_TranslateKey : FunParams_Base
 {
     UINT64 lpImeContext; UINT vkCode; UINT uScanCode; BOOL bKeyDown;
     BYTE byKeyState[];
     BOOL bEaten;
     FUNID(ISinstar_TranslateKey)
     PARAMS5(Input, lpImeContext, vkCode, uScanCode, bKeyDown, byKeyState)
     PARAMS1(Output, bEaten)
 };

 struct Param_OnSetFocus : FunParams_Base
 {
     BOOL bFocus;
     FUNID(ISinstar_OnSetFocus)
         PARAMS1(Input, bFocus)
 };

 struct Param_GetCompositionSegments : FunParams_Base
 {
     int nSegs;
     FUNID(ISinstar_GetCompositionSegments)
         PARAMS1(Output, nSegs)
 };

 struct Param_GetCompositionSegmentEnd : FunParams_Base
 {
     int iSeg;
     int iEnd;
     FUNID(ISinstar_GetCompositionSegmentEnd)
         PARAMS1(Input,iSeg)
         PARAMS1(Output,iEnd)
 };

 struct Param_GetCompositionSegmentAttr : FunParams_Base
 {
     int iSeg;
     int nAttr;
     FUNID(ISinstar_GetCompositionSegmentAttr)
         PARAMS1(Input, iSeg)
         PARAMS1(Output, nAttr)
 };

 struct Param_OnOpenStatusChanged : FunParams_Base
 {
     BOOL bOpen;
     FUNID(ISinstar_OnOpenStatusChanged)
         PARAMS1(Input, bOpen)
 };

 struct Param_OnConversionModeChanged : FunParams_Base
 {
     EInputMethod uMode;
     FUNID(ISinstar_OnConversionModeChanged)
         PARAMS1(Input, uMode)
 };

 struct Param_ShowHelp : FunParams_Base
 {
     FUNID(ISinstar_ShowHelp)
 };

 struct Param_GetDefInputMode : FunParams_Base
 {
     EInputMethod uMode;
     FUNID(ISinstar_GetDefInputMode)
         PARAMS1(Output,uMode)
 };

 ////////////////////////////////////////////////////////////////////////////
 struct Param_InputStringW : FunParams_Base
 {
     std::wstring buf;
     BOOL bRet;
     FUNID(ITextService_InputStringW)
         PARAMS1(Input,buf)
         PARAMS1(Output,bRet)
 };

 struct Param_IsCompositing : FunParams_Base
 {
     BOOL bRet;
     FUNID(ITextService_IsCompositing)
         PARAMS1(Output,bRet)
 };

 struct Param_StartComposition : FunParams_Base
 {
     UINT64 lpImeContext;
     FUNID(ITextService_StartComposition)
         PARAMS1(Input,lpImeContext)
 };

 struct Param_ReplaceSelCompositionW : FunParams_Base
 {
     UINT64 lpImeContext; int nLeft; int nRight; std::wstring buf;
     FUNID(ITextService_ReplaceSelCompositionW)
         PARAMS4(Input,lpImeContext,nLeft,nRight,buf)
 };

 struct Param_UpdateResultAndCompositionStringW : FunParams_Base
 {
     UINT64 lpImeContext; std::wstring resultStr; std::wstring compStr;
     FUNID(ITextService_UpdateResultAndCompositionStringW)
         PARAMS3(Input, lpImeContext, resultStr, compStr)
 };

 struct Param_EndComposition : FunParams_Base
 {
     UINT64 lpImeContext;
     FUNID(ITextService_EndComposition)
         PARAMS1(Input,lpImeContext)
 };

 struct Param_GetImeContext : FunParams_Base
 {
     UINT64 lpImeContext;
     FUNID(ITextService_GetImeContext)
         PARAMS1(Output,lpImeContext)
 };

 struct Param_ReleaseImeContext : FunParams_Base
 {
     UINT64 lpImeContext;
     BOOL bRet;
     FUNID(ITextService_ReleaseImeContext)
         PARAMS1(Input, lpImeContext)
         PARAMS1(Output,bRet)
 };

 struct Param_SetConversionMode : FunParams_Base
 {
     EInputMethod mode;
     FUNID(ITextService_SetConversionMode)
         PARAMS1(Input,mode)
 };

 struct Param_GetConversionMode : FunParams_Base
 {
     EInputMethod mode;
     FUNID(ITextService_GetConversionMode)
         PARAMS1(Output, mode)
 };

 struct Param_SetOpenStatus : FunParams_Base
 {
     UINT64 lpImeContext;
     BOOL bOpen;
     BOOL bRet;
     FUNID(ITextService_SetOpenStatus)
         PARAMS2(Input,lpImeContext,bOpen)
         PARAMS1(Output,bRet)
 };

 struct Param_GetOpenStatus : FunParams_Base
 {
     UINT64 lpImeContext;
     BOOL bOpen;
     FUNID(ITextService_GetOpenStatus)
         PARAMS1(Input, lpImeContext)
         PARAMS1(Output, bOpen)
 };

 struct Param_GetActiveWnd : FunParams_Base
 {
     DWORD hActive;
     FUNID(ITextService_GetActiveWnd)
         PARAMS1(Output, hActive)
 }

首先我们通过一组枚举值定义所有调用的函数ID。

然后实现一个继承自IFunParams的对象FunParams_Base，以实现接口中的缺省方法。

然后从FunParams_Base继承出每一个IPC调用需要的参数。

我们以256行的Param_InputStringW为例来说明如何定义方法参数。

struct Param_InputStringW : FunParams_Base
{
    std::wstring buf;
    BOOL bRet;
    FUNID(ITextService_InputStringW)
        PARAMS1(Input,buf)
        PARAMS1(Output,bRet)
};

这个IPC调用输入是一个wstring字符串，输出是一个BOOL类型返回值。

首先在对象中定义这两个成员变量。

定义好后通过宏FUNID来指定这个方法的函数调用ID。

再通过宏PARAM1(Input,buf)来指定这个方法的输入参数buf, 注意宏的第一个参数"input"。

第三步通过宏PARAM1(output,bRet)来定义这个方法的输出变量为bRet. PARAMX目前实现的X范围为1-5, 分别对应1-5个参数，如果在一次调用中有更多参数，可以参考PARAMX的实现多写几个宏就好了。

实际上这些宏就是为了组合IFunParams的几个虚方法。

这个对象在进行IPC调用的时候，先在请求端借助SParamStream对象序列化到共享内存中，SParamStream重载了输入"<<"及输出">>"操作符，默认操作是直接拷贝变量内存，这对于基本变量类型是适用的，但是对于string,wstring等对象就不适用了，对于那些不能通过简单的内存拷贝来传递的对象，我们需要像协议开头那样为这些类型的序列化做模板特化。对于比如POINT这样的对象也是可以直接通过内存拷贝就可以实现序列化的，因此这里对POINT的特化其实是多余的（最新的代码已经删除）。

协议定义好后，我们来看看如何进行IPC调用及响应IPC调用。

 class CClientConnection : public SOUI::TObjRefImpl<SOUI::IIpcConnection>
 {
 public:
     CClientConnection(ITextService * pTxtService);

 public:
     // 通过 IIpcConnection 继承
     virtual SOUI::IIpcHandle * GetIpcHandle() override;
     virtual void BuildShareBufferName(ULONG_PTR idLocal, ULONG_PTR idRemote, TCHAR szName[MAX_PATH]) const override;
     bool CallFun(SOUI::IFunParams *params) const;
 protected:
     void OnInputStringW( Param_InputStringW &param);
     void OnIsCompositing( Param_IsCompositing &param);
     void OnStartComposition( Param_StartComposition &param);
     void OnReplaceSelCompositionW( Param_ReplaceSelCompositionW &param);
     void OnUpdateResultAndCompositionStringW( Param_UpdateResultAndCompositionStringW &param);
     void OnEndComposition( Param_EndComposition &param);
     void OnGetImeContext( Param_GetImeContext &param);
     void OnReleaseImeContext( Param_ReleaseImeContext &param);
     void OnSetConversionMode( Param_SetConversionMode &param);
     void OnGetConversionMode( Param_GetConversionMode &param);
     void OnSetOpenStatus( Param_SetOpenStatus &param);
     void OnGetOpenStatus( Param_GetOpenStatus &param);
     void OnGetActiveWnd( Param_GetActiveWnd &param);

     FUN_BEGIN
         FUN_HANDLER(Param_InputStringW, OnInputStringW)
         FUN_HANDLER(Param_IsCompositing, OnIsCompositing)
         FUN_HANDLER(Param_StartComposition, OnStartComposition)
         FUN_HANDLER(Param_ReplaceSelCompositionW, OnReplaceSelCompositionW)
         FUN_HANDLER(Param_UpdateResultAndCompositionStringW, OnUpdateResultAndCompositionStringW)
         FUN_HANDLER(Param_EndComposition, OnEndComposition)
         FUN_HANDLER(Param_GetImeContext, OnGetImeContext)
         FUN_HANDLER(Param_ReleaseImeContext, OnReleaseImeContext)
         FUN_HANDLER(Param_SetConversionMode, OnSetConversionMode)
         FUN_HANDLER(Param_GetConversionMode, OnGetConversionMode)
         FUN_HANDLER(Param_SetOpenStatus, OnSetOpenStatus)
         FUN_HANDLER(Param_GetOpenStatus, OnGetOpenStatus)
         FUN_HANDLER(Param_GetActiveWnd, OnGetActiveWnd)
     FUN_END

 private:
     ITextService * m_pTxtService;
     SOUI::CAutoRefPtr<SOUI::IIpcHandle> m_ipcHandle;
 };

 bool CClientConnection::CallFun(SOUI::IFunParams *params) const
 {
     SASSERT(m_ipcHandle);
     return m_ipcHandle->CallFun(params);
 }

 void CSinstarProxy::ProcessKeyStoke(UINT64 imeContext, UINT vkCode, LPARAM lParam, BOOL bKeyDown, BYTE byKeyState[], BOOL * pbEaten)
 {
     Param_ProcessKeyStoke param;
     param.lpImeContext = imeContext;
     param.vkCode = vkCode;
     param.lParam = (DWORD)lParam;
     param.bKeyDown = bKeyDown;
     memcpy(param.byKeyState, byKeyState, );
     param.bEaten = false;
     m_conn.CallFun(&param);
     *pbEaten = param.bEaten;
 }

CSinstarProxy对象有一个CClientConnection对象：m_conn，它需要调用服务器的方法ProcessKeyStoke,我们需要把对应的函数参数包装到对象：Param_ProcessKeyStoke中，调用m_conn.CallFun(&param)，再从参数中获取返回值。

在CClientConnection对象中有一组FUN_BEGIN,FUN_END包装的处理函数映射表，分别用来处理服务端对客户端的函数调用。

如此，一个客户端服务器双向调用的IPC就完成了。

这个IPC核心就是用参数对象来包装参数列表并经过序列化，反序列化来实现跨进程函数调用，并通过实现一些宏简化开发，美化代码结构，目前在我的启程输入法3.0中工作很好。

启程输入法3.0 GIT仓库： https://gitee.com/setoutsoft/sinstar3

启程软件 2019-02-03