!4 修复静态扫描问题

Merge pull request !4 from demon/master

frameworks/inputmethod_ability/include/event_target.h

@@ -13,8 +13,8 @@
  * limitations under the License.
  */
 
-#ifndef FOUNDATION_ACE_NAPI_TEST_NATIVE_MODULE_NETSERVER_EVENT_TARGET_H
-#define FOUNDATION_ACE_NAPI_TEST_NATIVE_MODULE_NETSERVER_EVENT_TARGET_H
+#ifndef INPUT_METHOD_NAPI_EVENT_TARGET_H
+#define INPUT_METHOD_NAPI_EVENT_TARGET_H
 
 #include "napi/native_api.h"
 #include "global.h"
@@ -23,7 +23,6 @@
 namespace OHOS {
 namespace MiscServices {
 struct EventListener;
-
 class Event {
 public:
     virtual napi_value ToJsObject() = 0;
@@ -48,4 +47,4 @@ protected:
 };
 }
 }
-#endif /* FOUNDATION_ACE_NAPI_TEST_NATIVE_MODULE_NETSERVER_EVENT_TARGET_H */
+#endif // INPUT_METHOD_NAPI_EVENT_TARGET_H

frameworks/inputmethod_ability/include/input_method_ability.h

@@ -66,7 +66,6 @@ namespace MiscServices {
         sptr<InputMethodSystemAbilityProxy> mImms;
         sptr<InputMethodSystemAbilityProxy> GetImsaProxy();
 
-
         void Initialize();
         void WorkThread();
         void CreateInputMethodAgent(bool supportPhysicalKbd);

frameworks/inputmethod_ability/include/input_method_core_proxy.h

@@ -43,7 +43,7 @@ namespace MiscServices {
         virtual bool showKeyboard(int32_t flags) override;
         virtual bool hideKeyboard(int32_t flags) override;
         virtual int32_t setKeyboardType(const KeyboardType& type) override;
-        virtual int32_t getKeyboardWindowHeight(int32_t * retHeight) override;
+        virtual int32_t getKeyboardWindowHeight(int32_t *retHeight) override;
 
     private:
         static inline BrokerDelegator<InputMethodCoreProxy> delegator_;

frameworks/inputmethod_ability/include/input_method_core_stub.h

@@ -52,7 +52,7 @@ namespace MiscServices {
         virtual bool showKeyboard(int32_t flags) override;
         virtual bool hideKeyboard(int32_t flags)override;
         virtual int32_t setKeyboardType(const KeyboardType& type) override;
-        virtual int32_t getKeyboardWindowHeight(int32_t * retHeight) override;
+        virtual int32_t getKeyboardWindowHeight(int32_t *retHeight) override;
         void SetMessageHandler(MessageHandler* msgHandler);
 
     private:

frameworks/inputmethod_ability/src/input_method_ability.cpp

@@ -12,9 +12,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
-
-
 #include "input_method_ability.h"
 #include "input_method_core_proxy.h"
 #include "input_method_core_stub.h"

frameworks/inputmethod_ability/src/input_method_agent_proxy.cpp

@@ -18,7 +18,8 @@
 namespace OHOS {
 namespace MiscServices {
     using namespace ErrorCode;
-    InputMethodAgentProxy::InputMethodAgentProxy(const sptr<IRemoteObject> &object) : IRemoteProxy<IInputMethodAgent>(object) {
+    InputMethodAgentProxy::InputMethodAgentProxy(const sptr<IRemoteObject> &object)
+    : IRemoteProxy<IInputMethodAgent>(object) {
     }
 
     int32_t InputMethodAgentProxy::DispatchKey(int32_t key, int32_t status) {

frameworks/inputmethod_ability/src/input_method_agent_stub.cpp

@@ -28,7 +28,8 @@ namespace MiscServices {
     InputMethodAgentStub::~InputMethodAgentStub() {
     }
 
-    int32_t InputMethodAgentStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
+    int32_t InputMethodAgentStub::OnRemoteRequest(uint32_t code, MessageParcel &data,
+                                                  MessageParcel &reply, MessageOption &option) {
         IMSA_HILOGI("InputMethodAgentStub::OnRemoteRequest code = %{public}d", code);
         auto descriptorToken = data.ReadInterfaceToken();
         if (descriptorToken != GetDescriptor()) {

frameworks/inputmethod_ability/src/input_method_core_proxy.cpp

@@ -20,12 +20,14 @@
 
 namespace OHOS {
 namespace MiscServices {
-    InputMethodCoreProxy::InputMethodCoreProxy(const OHOS::sptr<OHOS::IRemoteObject> &impl) : IRemoteProxy<IInputMethodCore>(impl) {
+    InputMethodCoreProxy::InputMethodCoreProxy(const OHOS::sptr<OHOS::IRemoteObject> &impl)
+    : IRemoteProxy<IInputMethodCore>(impl) {
     }
 
     InputMethodCoreProxy::~InputMethodCoreProxy() = default;
 
-    int32_t InputMethodCoreProxy::initializeInput(sptr<IRemoteObject> &startInputToken, int32_t displayId, sptr<IInputControlChannel> &inputControlChannel) {
+    int32_t InputMethodCoreProxy::initializeInput(sptr<IRemoteObject> &startInputToken, int32_t displayId,
+                                                  sptr<IInputControlChannel> &inputControlChannel) {
         IMSA_HILOGI("InputMethodCoreProxy::initializeInput");
         if (startInputToken == nullptr) {
             IMSA_HILOGI("InputMethodCoreProxy::initializeInput startInputToken is nullptr");
@@ -58,7 +60,8 @@ namespace MiscServices {
         return code;
     }
 
-    bool InputMethodCoreProxy::startInput(const sptr<IInputDataChannel> &inputDataChannel, const InputAttribute& editorAttribute, bool supportPhysicalKbd) {
+    bool InputMethodCoreProxy::startInput(const sptr<IInputDataChannel> &inputDataChannel,
+                                          const InputAttribute& editorAttribute, bool supportPhysicalKbd) {
         IMSA_HILOGI("InputMethodCoreProxy::startInput");
         if (inputDataChannel == nullptr) {
             IMSA_HILOGI("InputMethodCoreProxy::startInput inputDataChannel is nullptr");
@@ -160,7 +163,7 @@ namespace MiscServices {
         return code;
     }
 
-    int32_t InputMethodCoreProxy::getKeyboardWindowHeight(int32_t * retHeight) {
+    int32_t InputMethodCoreProxy::getKeyboardWindowHeight(int32_t* retHeight) {
         IMSA_HILOGI("InputMethodCoreProxy::getKeyboardWindowHeight");
         MessageParcel data, reply;
         data.WriteInterfaceToken(GetDescriptor());

frameworks/inputmethod_ability/src/input_method_core_stub.cpp

@@ -12,8 +12,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
-
 #include <chrono>
 #include <stdint.h>
 #include "message_handler.h"
@@ -39,7 +37,8 @@ namespace MiscServices {
     InputMethodCoreStub::~InputMethodCoreStub() {
     }
 
-    int32_t InputMethodCoreStub::OnRemoteRequest(uint32_t code, MessageParcel & data, MessageParcel & reply, MessageOption & option) {
+    int32_t InputMethodCoreStub::OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply,
+                                                 MessageOption& option) {
         IMSA_HILOGI("InputMethodCoreStub::OnRemoteRequest");
         auto descriptorToken = data.ReadInterfaceToken();
         if (descriptorToken != GetDescriptor()) {
@@ -112,7 +111,8 @@ namespace MiscServices {
         return NO_ERROR;
     }
 
-    int32_t InputMethodCoreStub::initializeInput(sptr<IRemoteObject>& startInputToken, int32_t displayId, sptr<IInputControlChannel>& inputControlChannel) {
+    int32_t InputMethodCoreStub::initializeInput(sptr<IRemoteObject>& startInputToken, int32_t displayId,
+        sptr<IInputControlChannel>& inputControlChannel) {
         IMSA_HILOGI("InputMethodCoreStub::initializeInput");
         if (msgHandler_==nullptr) {
             return ErrorCode::ERROR_NULL_POINTER;
@@ -133,7 +133,8 @@ namespace MiscServices {
         return ErrorCode::NO_ERROR;
     }
 
-    bool InputMethodCoreStub::startInput(const sptr<IInputDataChannel>& inputDataChannel, const InputAttribute& editorAttribute, bool supportPhysicalKbd) {
+    bool InputMethodCoreStub::startInput(const sptr<IInputDataChannel>& inputDataChannel,
+        const InputAttribute& editorAttribute, bool supportPhysicalKbd) {
         IMSA_HILOGI("InputMethodCoreStub::startInput");
         if (msgHandler_ == nullptr) {
             return ErrorCode::ERROR_NULL_POINTER;
@@ -202,7 +203,7 @@ namespace MiscServices {
         return ErrorCode::NO_ERROR;
     }
 
-    int32_t InputMethodCoreStub::getKeyboardWindowHeight(int32_t * retHeight) {
+    int32_t InputMethodCoreStub::getKeyboardWindowHeight(int32_t* retHeight) {
         IMSA_HILOGI("InputMethodCoreStub::getKeyboardWindowHeight");
         if (msgHandler_==nullptr) {
             return ErrorCode::ERROR_NULL_POINTER;

frameworks/inputmethod_controller/include/i_input_client.h

@@ -27,21 +27,21 @@
  */
 namespace OHOS {
 namespace MiscServices {
-  class IInputClient : public IRemoteBroker {
-  public:
-      enum {
-          ON_INPUT_READY              = 0,
-          ON_INPUT_RELEASED           ,
-          SET_DISPLAY_MODE            ,
-      };
+    class IInputClient : public IRemoteBroker {
+    public:
+        enum {
+            ON_INPUT_READY = 0,
+            ON_INPUT_RELEASED,
+            SET_DISPLAY_MODE,
+        };
 
-      DECLARE_INTERFACE_DESCRIPTOR(u"ohos.miscservices.inputmethod.InputClient");
+        DECLARE_INTERFACE_DESCRIPTOR(u"ohos.miscservices.inputmethod.InputClient");
 
-      virtual int32_t onInputReady(int32_t retValue, const sptr<IInputMethodAgent>& agent, const InputChannel* channel) = 0;
-      virtual int32_t onInputReleased(int32_t retValue) = 0;
-      virtual int32_t setDisplayMode(int32_t mode) = 0;
-  };
+        virtual int32_t onInputReady(int32_t retValue, const sptr<IInputMethodAgent>& agent,
+            const InputChannel* channel) = 0;
+        virtual int32_t onInputReleased(int32_t retValue) = 0;
+        virtual int32_t setDisplayMode(int32_t mode) = 0;
+    };
 } 
 }
-
-#endif // FM_IMMS_PROJECT_IINPUTCLIENT_H
+#endif // FM_IMMS_PROJECT_IINPUTCLIENT_H

frameworks/inputmethod_controller/include/i_input_data_channel.h

@@ -25,7 +25,7 @@
  */
 namespace OHOS {
 namespace MiscServices {
-    class IInputDataChannel: public IRemoteBroker {
+    class IInputDataChannel : public IRemoteBroker {
     public:
         enum {
             INSERT_TEXT = 0,

frameworks/inputmethod_controller/include/input_client_proxy.h

@@ -22,9 +22,7 @@
 
 namespace OHOS {
 namespace MiscServices {
-
-class InputClientProxy : public IRemoteProxy<IInputClient>
-{
+class InputClientProxy : public IRemoteProxy<IInputClient> {
 public:
     explicit InputClientProxy(const sptr<IRemoteObject> &object);
     ~InputClientProxy() = default;

frameworks/inputmethod_controller/include/input_data_channel_proxy.h

@@ -13,8 +13,6 @@
  * limitations under the License.
  */
 
-
-
 #ifndef FM_IMC_PROJECT_INPUTDATACHANNELPROXY_H
 #define FM_IMC_PROJECT_INPUTDATACHANNELPROXY_H
 
@@ -23,21 +21,19 @@
 
 namespace OHOS {
 namespace MiscServices {
+    class InputDataChannelProxy : public IRemoteProxy<IInputDataChannel> {
+    public:
+        explicit InputDataChannelProxy(const sptr<IRemoteObject> &object);
+        ~InputDataChannelProxy() = default;
+        DISALLOW_COPY_AND_MOVE(InputDataChannelProxy);
 
-class InputDataChannelProxy : public IRemoteProxy<IInputDataChannel>
-{
-public:
-    explicit InputDataChannelProxy(const sptr<IRemoteObject> &object);
-    ~InputDataChannelProxy() = default;
-    DISALLOW_COPY_AND_MOVE(InputDataChannelProxy);
+        bool InsertText(const std::u16string& text) override;
+        bool DeleteBackward(int32_t length) override;
+        void Close() override;
 
-    bool InsertText(const std::u16string& text) override;
-    bool DeleteBackward(int32_t length) override;
-    void Close() override;
-
-private:
-    static inline BrokerDelegator<InputDataChannelProxy> delegator_;
-};
+    private:
+        static inline BrokerDelegator<InputDataChannelProxy> delegator_;
+    };
 }
 }
 #endif

frameworks/inputmethod_controller/include/input_method_controller.h

@@ -17,7 +17,6 @@
 #ifndef FM_IMC_PROJECT_INPUTMETHODCONTROLLER_H
 #define FM_IMC_PROJECT_INPUTMETHODCONTROLLER_H
 
-//#include "refbase.h"
 #include <mutex>
 #include <thread>
 #include "input_data_channel_stub.h"
@@ -30,7 +29,6 @@
 
 namespace OHOS {
 namespace MiscServices {
-
     class OnTextChangedListener : public virtual RefBase {
     public:
         virtual void InsertText(const std::u16string& text) = 0;
@@ -60,7 +58,8 @@ namespace MiscServices {
 
         bool Initialize();
         sptr<InputMethodSystemAbilityProxy> GetImsaProxy();
-        void PrepareInput(int32_t displayId,sptr<InputClientStub> &client,sptr<InputDataChannelStub> &channel,InputAttribute &attribute);
+        void PrepareInput(int32_t displayId, sptr<InputClientStub> &client, sptr<InputDataChannelStub> &channel,
+                          InputAttribute &attribute);
         void StartInput(sptr<InputClientStub> &client);
         void StopInput(sptr<InputClientStub> &client);
         void ReleaseInput(sptr<InputClientStub> &client);

frameworks/inputmethod_controller/include/input_method_system_ability_proxy.h

@@ -13,7 +13,6 @@
  * limitations under the License.
  */
 
-
 #ifndef FM_IMC_PROJECT_INPUTMETHODSYSTEMABILITYPROXY_H
 #define FM_IMC_PROJECT_INPUTMETHODSYSTEMABILITYPROXY_H
 
@@ -30,35 +29,34 @@
 
 namespace OHOS {
 namespace MiscServices {
+class InputMethodSystemAbilityProxy : public IRemoteProxy<IInputMethodSystemAbility> {
+    public:
+        explicit InputMethodSystemAbilityProxy(const sptr<IRemoteObject> &object);
+        ~InputMethodSystemAbilityProxy() = default;
+        DISALLOW_COPY_AND_MOVE(InputMethodSystemAbilityProxy);
 
-class InputMethodSystemAbilityProxy : public IRemoteProxy<IInputMethodSystemAbility>
-{
-public:
-    explicit InputMethodSystemAbilityProxy(const sptr<IRemoteObject> &object);
-    ~InputMethodSystemAbilityProxy() = default;
-    DISALLOW_COPY_AND_MOVE(InputMethodSystemAbilityProxy);
+        virtual void prepareInput(MessageParcel& data) override;
+        virtual void releaseInput(MessageParcel& data) override;
+        virtual void startInput(MessageParcel& data) override;
+        virtual void stopInput(MessageParcel& data) override;
+        virtual int32_t setInputMethodCore(sptr<IInputMethodCore> &core) override;
 
-    virtual void prepareInput(MessageParcel& data) override;
-    virtual void releaseInput(MessageParcel& data) override;
-    virtual void startInput(MessageParcel& data) override;
-    virtual void stopInput(MessageParcel& data) override;
-    virtual int32_t setInputMethodCore(sptr<IInputMethodCore> &core) override;
+        int32_t Prepare(int32_t displayId, sptr<InputClientStub> &client, sptr<InputDataChannelStub> &channel,
+                        InputAttribute &attribute);
+        int32_t Release(sptr<InputClientStub> &client);
+        int32_t Start(sptr<InputClientStub> &client);
+        int32_t Stop(sptr<InputClientStub> &client);
 
-    int32_t Prepare(int32_t displayId, sptr<InputClientStub> &client, sptr<InputDataChannelStub> &channel, InputAttribute &attribute);
-    int32_t Release(sptr<InputClientStub> &client);
-    int32_t Start(sptr<InputClientStub> &client);
-    int32_t Stop(sptr<InputClientStub> &client);
+        virtual int32_t getDisplayMode(int32_t *retMode) override;
+        virtual int32_t getKeyboardWindowHeight(int32_t *retHeight) override;
+        virtual int32_t getCurrentKeyboardType(KeyboardType* retType) override;
+        virtual int32_t listInputMethodEnabled(std::vector<InputMethodProperty*> *properties) override;
+        virtual int32_t listInputMethod(std::vector<InputMethodProperty*> *properties) override;
+        virtual int32_t listKeyboardType(const std::u16string& imeId, std::vector<KeyboardType*> *types) override;
 
-    virtual int32_t getDisplayMode(int32_t *retMode) override;
-    virtual int32_t getKeyboardWindowHeight(int32_t *retHeight) override;
-    virtual int32_t getCurrentKeyboardType(KeyboardType* retType) override;
-    virtual int32_t listInputMethodEnabled(std::vector<InputMethodProperty*> *properties) override;
-    virtual int32_t listInputMethod(std::vector<InputMethodProperty*> *properties) override;
-    virtual int32_t listKeyboardType(const std::u16string& imeId, std::vector<KeyboardType*> *types) override;
-
-private:
-    static inline BrokerDelegator<InputMethodSystemAbilityProxy> delegator_;
-};
+    private:
+        static inline BrokerDelegator<InputMethodSystemAbilityProxy> delegator_;
+    };
 }
 }
 #endif

frameworks/inputmethod_controller/src/input_client_proxy.cpp

@@ -18,12 +18,11 @@
 namespace OHOS {
 namespace MiscServices {
 using namespace ErrorCode;
-    InputClientProxy::InputClientProxy(const sptr<IRemoteObject> &object) : IRemoteProxy<IInputClient>(object)
-    {
+    InputClientProxy::InputClientProxy(const sptr<IRemoteObject> &object) : IRemoteProxy<IInputClient>(object) {
     }
 
-    int32_t InputClientProxy::onInputReady(int32_t retValue, const sptr<IInputMethodAgent>& agent, const InputChannel* channel)
-    {
+    int32_t InputClientProxy::onInputReady(int32_t retValue, const sptr<IInputMethodAgent>& agent,
+        const InputChannel* channel) {
         IMSA_HILOGI("InputClientProxy::onInputReady");
         MessageParcel data, reply;
         MessageOption option;

frameworks/inputmethod_controller/src/input_client_stub.cpp

@@ -18,88 +18,86 @@
 
 namespace OHOS {
 namespace MiscServices {
+    InputClientStub::InputClientStub()
+    {
 
-InputClientStub::InputClientStub()
-{
-
-}
-
-InputClientStub::~InputClientStub()
-{
-
-}
-
-int32_t InputClientStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply,
-    MessageOption &option)
-{
-    IMSA_HILOGI("InputClientStub::OnRemoteRequest. code = %{public}u", code);
-    auto descriptorToken = data.ReadInterfaceToken();
-    if (descriptorToken != GetDescriptor()) {
-        return ErrorCode::ERROR_STATUS_UNKNOWN_TRANSACTION;
     }
-    switch (code) {
-        case ON_INPUT_READY: {
-            if (msgHandler == nullptr) {
-                break;
-            }
-            MessageParcel* parcel = new MessageParcel();
-            parcel->WriteInt32(data.ReadInt32());
-            if (data.ReadInt32() > 0) {
-                parcel->WriteRemoteObject(data.ReadRemoteObject());
-            }
-            if (data.ReadInt32() > 0) {
-                parcel->WriteParcelable(data.ReadParcelable<InputChannel>());
-            }
 
-            Message* msg = new Message(MessageID::MSG_ID_ON_INPUT_READY, parcel);
-            msgHandler->SendMessage(msg);
-            break;
-        }
-        case ON_INPUT_RELEASED: {
-            if (msgHandler == nullptr) {
-                break;
-            }
-            MessageParcel* parcel = new MessageParcel();
-            parcel->WriteInt32(data.ReadInt32());
-            Message* msg = new Message(MessageID::MSG_ID_EXIT_SERVICE, parcel);
-            msgHandler->SendMessage(msg);
-            break;
-        }
-        case SET_DISPLAY_MODE: {
-            if (msgHandler == nullptr) {
-                break;
-            }
-            MessageParcel* parcel = new MessageParcel();
-            parcel->WriteInt32(data.ReadInt32());
-            Message* msg = new Message(MessageID::MSG_ID_SET_DISPLAY_MODE, parcel);
-            msgHandler->SendMessage(msg);
-            break;
-        }
-        default:
-            return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
+    InputClientStub::~InputClientStub()
+    {
+
     }
-    return NO_ERROR;
-}
 
-int32_t InputClientStub::onInputReady(int32_t retValue, const sptr<IInputMethodAgent>& agent, const InputChannel* channel)
-{
-    return ErrorCode::NO_ERROR;
-}
+    int32_t InputClientStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply,
+        MessageOption &option)
+    {
+        IMSA_HILOGI("InputClientStub::OnRemoteRequest. code = %{public}u", code);
+        auto descriptorToken = data.ReadInterfaceToken();
+        if (descriptorToken != GetDescriptor()) {
+            return ErrorCode::ERROR_STATUS_UNKNOWN_TRANSACTION;
+        }
+        switch (code) {
+            case ON_INPUT_READY: {
+                if (msgHandler == nullptr) {
+                    break;
+                }
+                MessageParcel* parcel = new MessageParcel();
+                parcel->WriteInt32(data.ReadInt32());
+                if (data.ReadInt32() > 0) {
+                    parcel->WriteRemoteObject(data.ReadRemoteObject());
+                }
+                if (data.ReadInt32() > 0) {
+                    parcel->WriteParcelable(data.ReadParcelable<InputChannel>());
+                }
 
-int32_t InputClientStub::onInputReleased(int32_t retValue)
-{
-    return ErrorCode::NO_ERROR;
-}
+                Message* msg = new Message(MessageID::MSG_ID_ON_INPUT_READY, parcel);
+                msgHandler->SendMessage(msg);
+                break;
+            }
+            case ON_INPUT_RELEASED: {
+                if (msgHandler == nullptr) {
+                    break;
+                }
+                MessageParcel* parcel = new MessageParcel();
+                parcel->WriteInt32(data.ReadInt32());
+                Message* msg = new Message(MessageID::MSG_ID_EXIT_SERVICE, parcel);
+                msgHandler->SendMessage(msg);
+                break;
+            }
+            case SET_DISPLAY_MODE: {
+                if (msgHandler == nullptr) {
+                    break;
+                }
+                MessageParcel* parcel = new MessageParcel();
+                parcel->WriteInt32(data.ReadInt32());
+                Message* msg = new Message(MessageID::MSG_ID_SET_DISPLAY_MODE, parcel);
+                msgHandler->SendMessage(msg);
+                break;
+            }
+            default:
+                return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
+        }
+        return NO_ERROR;
+    }
 
-int32_t InputClientStub::setDisplayMode(int32_t mode)
-{
-    return ErrorCode::NO_ERROR;
-}
+    int32_t InputClientStub::onInputReady(int32_t retValue, const sptr<IInputMethodAgent>& agent,
+        const InputChannel* channel) {
+        return ErrorCode::NO_ERROR;
+    }
 
-void InputClientStub::SetHandler(MessageHandler* handler)
-{
-    msgHandler = handler;
-}
+    int32_t InputClientStub::onInputReleased(int32_t retValue)
+    {
+        return ErrorCode::NO_ERROR;
+    }
 
+    int32_t InputClientStub::setDisplayMode(int32_t mode)
+    {
+        return ErrorCode::NO_ERROR;
+    }
+
+    void InputClientStub::SetHandler(MessageHandler* handler)
+    {
+        msgHandler = handler;
+    }
 }
 }

frameworks/inputmethod_controller/src/input_data_channel_proxy.cpp

@@ -19,55 +19,53 @@
 
 namespace OHOS {
 namespace MiscServices {
-
-InputDataChannelProxy::InputDataChannelProxy(const sptr<IRemoteObject> &object) : IRemoteProxy<IInputDataChannel>(object)
-{
-
-}
-
-bool InputDataChannelProxy::InsertText(const std::u16string& text)
-{
-    IMSA_HILOGI("InputDataChannelProxy::InsertText");
-    MessageParcel data, reply;
-    MessageOption option;
-    data.WriteInterfaceToken(GetDescriptor());
-    data.WriteString16(text);
-
-    auto ret = Remote()->SendRequest(INSERT_TEXT, data, reply, option);
-    if (ret != NO_ERROR) {
-        return false;
+    InputDataChannelProxy::InputDataChannelProxy(const sptr<IRemoteObject> &object)
+        : IRemoteProxy<IInputDataChannel>(object) {
     }
-    auto result = reply.ReadBool();
-    return result;
-}
 
-bool InputDataChannelProxy::DeleteBackward(int32_t length)
-{
-    IMSA_HILOGI("InputDataChannelProxy::DeleteBackward");
-    MessageParcel data, reply;
-    MessageOption option;
-    data.WriteInterfaceToken(GetDescriptor());
-    data.WriteInt32(length);
+    bool InputDataChannelProxy::InsertText(const std::u16string& text)
+    {
+        IMSA_HILOGI("InputDataChannelProxy::InsertText");
+        MessageParcel data, reply;
+        MessageOption option;
+        data.WriteInterfaceToken(GetDescriptor());
+        data.WriteString16(text);
 
-    auto ret = Remote()->SendRequest(DELETE_BACKWARD, data, reply, option);
-    if (ret != NO_ERROR) {
-        return false;
+        auto ret = Remote()->SendRequest(INSERT_TEXT, data, reply, option);
+        if (ret != NO_ERROR) {
+            return false;
+        }
+        auto result = reply.ReadBool();
+        return result;
     }
-    auto result = reply.ReadBool();
-    return result;
-}
 
-void InputDataChannelProxy::Close()
-{
-    IMSA_HILOGI("InputDataChannelProxy::Close");
-    MessageParcel data, reply;
-    MessageOption option;
-    data.WriteInterfaceToken(GetDescriptor());
+    bool InputDataChannelProxy::DeleteBackward(int32_t length)
+    {
+        IMSA_HILOGI("InputDataChannelProxy::DeleteBackward");
+        MessageParcel data, reply;
+        MessageOption option;
+        data.WriteInterfaceToken(GetDescriptor());
+        data.WriteInt32(length);
 
-    auto ret = Remote()->SendRequest(CLOSE, data, reply, option);
-    if (ret != NO_ERROR) {
-        
+        auto ret = Remote()->SendRequest(DELETE_BACKWARD, data, reply, option);
+        if (ret != NO_ERROR) {
+            return false;
+        }
+        auto result = reply.ReadBool();
+        return result;
+    }
+
+    void InputDataChannelProxy::Close()
+    {
+        IMSA_HILOGI("InputDataChannelProxy::Close");
+        MessageParcel data, reply;
+        MessageOption option;
+        data.WriteInterfaceToken(GetDescriptor());
+
+        auto ret = Remote()->SendRequest(CLOSE, data, reply, option);
+        if (ret != NO_ERROR) {
+
+        }
     }
-}
 }
 }

frameworks/inputmethod_controller/src/input_data_channel_stub.cpp

@@ -17,82 +17,82 @@
 
 namespace OHOS {
 namespace MiscServices {
-InputDataChannelStub::InputDataChannelStub() : msgHandler(nullptr)
-{
+    InputDataChannelStub::InputDataChannelStub() : msgHandler(nullptr)
+    {
 
-}
-
-InputDataChannelStub::~InputDataChannelStub()
-{
-    if (msgHandler != nullptr) {
-        delete msgHandler;
     }
-}
 
-int32_t InputDataChannelStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply,
-    MessageOption &option)
-{
-    IMSA_HILOGI("InputDataChannelStub::OnRemoteRequest code = %{public}d", code);
-    auto descriptorToken = data.ReadInterfaceToken();
-    if (descriptorToken != GetDescriptor()) {
-        return ErrorCode::ERROR_STATUS_UNKNOWN_TRANSACTION;
-    }
-    switch (code) {
-        case INSERT_TEXT: {
-            auto text = data.ReadString16();
-            InsertText(text);
-            break;
+    InputDataChannelStub::~InputDataChannelStub()
+    {
+        if (msgHandler != nullptr) {
+            delete msgHandler;
         }
-        case DELETE_BACKWARD: {
-            auto length = data.ReadInt32();
-            DeleteBackward(length);
-            break;
+    }
+
+    int32_t InputDataChannelStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply,
+        MessageOption &option)
+    {
+        IMSA_HILOGI("InputDataChannelStub::OnRemoteRequest code = %{public}d", code);
+        auto descriptorToken = data.ReadInterfaceToken();
+        if (descriptorToken != GetDescriptor()) {
+            return ErrorCode::ERROR_STATUS_UNKNOWN_TRANSACTION;
         }
-        case CLOSE: {
-            Close();
-            break;
+        switch (code) {
+            case INSERT_TEXT: {
+                auto text = data.ReadString16();
+                InsertText(text);
+                break;
+            }
+            case DELETE_BACKWARD: {
+                auto length = data.ReadInt32();
+                DeleteBackward(length);
+                break;
+            }
+            case CLOSE: {
+                Close();
+                break;
+            }
+            default:
+                return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
         }
-        default:
-            return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
+        return NO_ERROR;
     }
-    return NO_ERROR;
-}
 
-bool InputDataChannelStub::InsertText(const std::u16string& text)
-{
-    IMSA_HILOGI("InputDataChannelStub::InsertText");
-    if (msgHandler != nullptr) {
-        MessageParcel* parcel = new MessageParcel;
-        parcel->WriteString16(text);
-        Message* msg = new Message(MessageID::MSG_ID_INSERT_CHAR, parcel);
-        msgHandler->SendMessage(msg);
-        IMSA_HILOGI("InputDataChannelStub::InsertText return true");
-        return true;
+    bool InputDataChannelStub::InsertText(const std::u16string& text)
+    {
+        IMSA_HILOGI("InputDataChannelStub::InsertText");
+        if (msgHandler != nullptr) {
+            MessageParcel* parcel = new MessageParcel;
+            parcel->WriteString16(text);
+            Message* msg = new Message(MessageID::MSG_ID_INSERT_CHAR, parcel);
+            msgHandler->SendMessage(msg);
+            IMSA_HILOGI("InputDataChannelStub::InsertText return true");
+            return true;
+        }
+        return false;
     }
-    return false;
-}
 
-bool InputDataChannelStub::DeleteBackward(int32_t length)
-{
-    IMSA_HILOGI("InputDataChannelStub::DeleteBackward");
-    if (msgHandler != nullptr) {
-        MessageParcel* parcel = new MessageParcel;
-        parcel->WriteInt32(length);
-        Message* msg = new Message(MessageID::MSG_ID_DELETE_BACKWARD, parcel);
-        msgHandler->SendMessage(msg);
-        return true;
+    bool InputDataChannelStub::DeleteBackward(int32_t length)
+    {
+        IMSA_HILOGI("InputDataChannelStub::DeleteBackward");
+        if (msgHandler != nullptr) {
+            MessageParcel* parcel = new MessageParcel;
+            parcel->WriteInt32(length);
+            Message* msg = new Message(MessageID::MSG_ID_DELETE_BACKWARD, parcel);
+            msgHandler->SendMessage(msg);
+            return true;
+        }
+        return false;
     }
-    return false;
-}
 
-void InputDataChannelStub::Close()
-{
+    void InputDataChannelStub::Close()
+    {
 
-}
+    }
 
-void InputDataChannelStub::SetHandler(MessageHandler* handler)
-{
-    msgHandler = handler;
-}
+    void InputDataChannelStub::SetHandler(MessageHandler* handler)
+    {
+        msgHandler = handler;
+    }
 }
 }

frameworks/inputmethod_controller/src/input_method_controller.cpp

@@ -174,7 +174,8 @@ using namespace MessageID;
         ReleaseInput(mClient);
     }
 
-    void InputMethodController::PrepareInput(int32_t displayId,sptr<InputClientStub> &client,sptr<InputDataChannelStub> &channel,InputAttribute &attribute)
+    void InputMethodController::PrepareInput(int32_t displayId, sptr<InputClientStub> &client,
+                                             sptr<InputDataChannelStub> &channel, InputAttribute &attribute)
     {
         IMSA_HILOGI("InputMethodController::PrepareInput");
         if(mImms == nullptr){

frameworks/inputmethod_controller/src/input_method_system_ability_proxy.cpp

@@ -17,394 +17,395 @@
 
 namespace OHOS {
 namespace MiscServices {
-using namespace ErrorCode;
-
-InputMethodSystemAbilityProxy::InputMethodSystemAbilityProxy(const sptr<IRemoteObject> &object)
-    : IRemoteProxy<IInputMethodSystemAbility>(object)
-{
-
-}
-
-void InputMethodSystemAbilityProxy::prepareInput(MessageParcel& data)
-{
-    MessageParcel reply;
-    MessageOption option;
-
-    auto ret = Remote()->SendRequest(PREPARE_INPUT, data, reply, option);
-    if (ret != NO_ERROR) {
-        IMSA_HILOGI("InputMethodSystemAbilityProxy::prepareInput SendRequest failed");
-        return;
-    }
-
-    ret = reply.ReadInt32();
-    if (ret != NO_ERROR) {
-        IMSA_HILOGI("InputMethodSystemAbilityProxy::prepareInput reply failed");
-        return;
-    }
-}
-
-void InputMethodSystemAbilityProxy::releaseInput(MessageParcel& data)
-{
-    MessageParcel reply;
-    MessageOption option;
-
-    auto ret = Remote()->SendRequest(RELEASE_INPUT, data, reply, option);
-    if (ret != NO_ERROR) {
-        IMSA_HILOGI("InputMethodSystemAbilityProxy::releaseInput SendRequest failed");
-        return;
-    }
-
-    ret = reply.ReadInt32();
-    if (ret != NO_ERROR) {
-        IMSA_HILOGI("InputMethodSystemAbilityProxy::releaseInput reply failed");
-        return;
-    }
-}
-
-void InputMethodSystemAbilityProxy::startInput(MessageParcel& data)
-{
-    IMSA_HILOGI("InputMethodSystemAbilityProxy::startInput");
-    MessageParcel reply;
-    MessageOption option;
-
-    auto ret = Remote()->SendRequest(START_INPUT,data,reply,option);
-    if (ret != NO_ERROR) {
-        IMSA_HILOGI("InputMethodSystemAbilityProxy::startInput SendRequest failed");
-        return;
-    }
-
-    ret = reply.ReadInt32();
-    if (ret != NO_ERROR) {
-        IMSA_HILOGI("InputMethodSystemAbilityProxy::startInput reply failed");
-        return;
-    }
-}
-
-void InputMethodSystemAbilityProxy::stopInput(MessageParcel& data)
-{
-    IMSA_HILOGI("InputMethodSystemAbilityProxy::stopInput");
-    MessageParcel reply;
-    MessageOption option;
-
-    auto ret = Remote()->SendRequest(STOP_INPUT,data,reply,option);
-    if (ret != NO_ERROR) {
-        IMSA_HILOGI("InputMethodSystemAbilityProxy::stopInput SendRequest failed");
-        return;
-    }
-
-    ret = reply.ReadInt32();
-    if (ret != NO_ERROR) {
-        IMSA_HILOGI("InputMethodSystemAbilityProxy::stopInput reply failed");
-        return;
-    }
-}
-
-    int32_t InputMethodSystemAbilityProxy::setInputMethodCore(sptr<IInputMethodCore> &core)
+    using namespace ErrorCode;
+    InputMethodSystemAbilityProxy::InputMethodSystemAbilityProxy(const sptr<IRemoteObject> &object)
+        : IRemoteProxy<IInputMethodSystemAbility>(object)
     {
-        IMSA_HILOGI("InputMethodSystemAbilityProxy::setInputMethodCore");
 
-        if (core == nullptr) {
-            IMSA_HILOGI("InputMethodSystemAbilityProxy::setInputMethodCore inputDataChannel is nullptr");
-        }
-        auto remote = Remote();
-        if (remote == nullptr)
-            return -1;
-        MessageParcel data;
-        if (!(data.WriteInterfaceToken(GetDescriptor())
-        && data.WriteRemoteObject(core->AsObject())))
-            return -1;
+    }
+
+    void InputMethodSystemAbilityProxy::prepareInput(MessageParcel& data)
+    {
         MessageParcel reply;
-        MessageOption option { MessageOption::TF_SYNC };
+        MessageOption option;
 
-        int32_t status = Remote()->SendRequest(SET_INPUT_METHOD_CORE, data, reply, option);
+        auto ret = Remote()->SendRequest(PREPARE_INPUT, data, reply, option);
+        if (ret != NO_ERROR) {
+            IMSA_HILOGI("InputMethodSystemAbilityProxy::prepareInput SendRequest failed");
+            return;
+        }
 
-        return status;
+        ret = reply.ReadInt32();
+        if (ret != NO_ERROR) {
+            IMSA_HILOGI("InputMethodSystemAbilityProxy::prepareInput reply failed");
+            return;
+        }
     }
 
-int32_t InputMethodSystemAbilityProxy::Prepare(int32_t displayId, sptr<InputClientStub> &client, sptr<InputDataChannelStub> &channel, InputAttribute &attribute)
-{
-    MessageParcel data, reply;
-    MessageOption option;
-    if (!data.WriteInterfaceToken(GetDescriptor())) {
-        return ERROR_EX_PARCELABLE;
+    void InputMethodSystemAbilityProxy::releaseInput(MessageParcel& data)
+    {
+        MessageParcel reply;
+        MessageOption option;
+
+        auto ret = Remote()->SendRequest(RELEASE_INPUT, data, reply, option);
+        if (ret != NO_ERROR) {
+            IMSA_HILOGI("InputMethodSystemAbilityProxy::releaseInput SendRequest failed");
+            return;
+        }
+
+        ret = reply.ReadInt32();
+        if (ret != NO_ERROR) {
+            IMSA_HILOGI("InputMethodSystemAbilityProxy::releaseInput reply failed");
+            return;
+        }
     }
 
-    if (!(data.WriteInt32(displayId)
-            && data.WriteRemoteObject(client->AsObject())
-            && data.WriteRemoteObject(channel->AsObject())
-            && data.WriteParcelable(&attribute))) {
-                return ERROR_EX_PARCELABLE;
+    void InputMethodSystemAbilityProxy::startInput(MessageParcel& data)
+    {
+        IMSA_HILOGI("InputMethodSystemAbilityProxy::startInput");
+        MessageParcel reply;
+        MessageOption option;
+
+        auto ret = Remote()->SendRequest(START_INPUT,data,reply,option);
+        if (ret != NO_ERROR) {
+            IMSA_HILOGI("InputMethodSystemAbilityProxy::startInput SendRequest failed");
+            return;
+        }
+
+        ret = reply.ReadInt32();
+        if (ret != NO_ERROR) {
+            IMSA_HILOGI("InputMethodSystemAbilityProxy::startInput reply failed");
+            return;
+        }
+    }
+
+    void InputMethodSystemAbilityProxy::stopInput(MessageParcel& data)
+    {
+        IMSA_HILOGI("InputMethodSystemAbilityProxy::stopInput");
+        MessageParcel reply;
+        MessageOption option;
+
+        auto ret = Remote()->SendRequest(STOP_INPUT,data,reply,option);
+        if (ret != NO_ERROR) {
+            IMSA_HILOGI("InputMethodSystemAbilityProxy::stopInput SendRequest failed");
+            return;
+        }
+
+        ret = reply.ReadInt32();
+        if (ret != NO_ERROR) {
+            IMSA_HILOGI("InputMethodSystemAbilityProxy::stopInput reply failed");
+            return;
+        }
+    }
+
+        int32_t InputMethodSystemAbilityProxy::setInputMethodCore(sptr<IInputMethodCore> &core)
+        {
+            IMSA_HILOGI("InputMethodSystemAbilityProxy::setInputMethodCore");
+
+            if (core == nullptr) {
+                IMSA_HILOGI("InputMethodSystemAbilityProxy::setInputMethodCore inputDataChannel is nullptr");
             }
+            auto remote = Remote();
+            if (remote == nullptr)
+                return -1;
+            MessageParcel data;
+            if (!(data.WriteInterfaceToken(GetDescriptor())
+            && data.WriteRemoteObject(core->AsObject())))
+                return -1;
+            MessageParcel reply;
+            MessageOption option { MessageOption::TF_SYNC };
 
-    auto ret = Remote()->SendRequest(PREPARE_INPUT, data, reply, option);
-    if (ret != NO_ERROR) {
-        return ERROR_STATUS_FAILED_TRANSACTION;
+            int32_t status = Remote()->SendRequest(SET_INPUT_METHOD_CORE, data, reply, option);
+
+            return status;
+        }
+
+    int32_t InputMethodSystemAbilityProxy::Prepare(int32_t displayId, sptr<InputClientStub> &client,
+                                                   sptr<InputDataChannelStub> &channel, InputAttribute &attribute)
+    {
+        MessageParcel data, reply;
+        MessageOption option;
+        if (!data.WriteInterfaceToken(GetDescriptor())) {
+            return ERROR_EX_PARCELABLE;
+        }
+
+        if (!(data.WriteInt32(displayId)
+                && data.WriteRemoteObject(client->AsObject())
+                && data.WriteRemoteObject(channel->AsObject())
+                && data.WriteParcelable(&attribute))) {
+                    return ERROR_EX_PARCELABLE;
+                }
+
+        auto ret = Remote()->SendRequest(PREPARE_INPUT, data, reply, option);
+        if (ret != NO_ERROR) {
+            return ERROR_STATUS_FAILED_TRANSACTION;
+        }
+
+        ret = reply.ReadInt32();
+        if (ret != NO_ERROR) {
+            return ret;
+        }
+
+        return NO_ERROR;
     }
 
-    ret = reply.ReadInt32();
-    if (ret != NO_ERROR) {
-        return ret;
+    int32_t InputMethodSystemAbilityProxy::Release(sptr<InputClientStub> &client)
+    {
+        IMSA_HILOGI("InputMethodSystemAbilityProxy::Release");
+        MessageParcel data, reply;
+        MessageOption option;
+        if (!data.WriteInterfaceToken(GetDescriptor())) {
+            return ERROR_EX_PARCELABLE;
+        }
+
+        if (!data.WriteRemoteObject(client->AsObject().GetRefPtr())) {
+            return ERROR_EX_PARCELABLE;
+        }
+
+        auto ret = Remote()->SendRequest(RELEASE_INPUT, data, reply, option);
+        if (ret != NO_ERROR) {
+            return ERROR_STATUS_FAILED_TRANSACTION;
+        }
+
+        ret = reply.ReadInt32();
+        if (ret != NO_ERROR) {
+            return ret;
+        }
+
+        return NO_ERROR;
     }
 
-    return NO_ERROR;
-}
+    int32_t InputMethodSystemAbilityProxy::Start(sptr<InputClientStub> &client)
+    {
+        MessageParcel data, reply;
+        MessageOption option;
+        if (!data.WriteInterfaceToken(GetDescriptor())) {
+            return ERROR_EX_PARCELABLE;
+        }
 
-int32_t InputMethodSystemAbilityProxy::Release(sptr<InputClientStub> &client)
-{
-    IMSA_HILOGI("InputMethodSystemAbilityProxy::Release");
-    MessageParcel data, reply;
-    MessageOption option;
-    if (!data.WriteInterfaceToken(GetDescriptor())) {
-        return ERROR_EX_PARCELABLE;
+        if (!data.WriteRemoteObject(client->AsObject().GetRefPtr())) {
+            return ERROR_EX_PARCELABLE;
+        }
+
+        auto ret = Remote()->SendRequest(START_INPUT, data, reply, option);
+        if (ret != NO_ERROR) {
+            return ERROR_STATUS_FAILED_TRANSACTION;
+        }
+
+        ret = reply.ReadInt32();
+        if (ret != NO_ERROR) {
+            return ret;
+        }
+
+        return NO_ERROR;
     }
 
-    if (!data.WriteRemoteObject(client->AsObject().GetRefPtr())) {
-        return ERROR_EX_PARCELABLE;
+    int32_t InputMethodSystemAbilityProxy::Stop(sptr<InputClientStub> &client)
+    {
+        MessageParcel data, reply;
+        MessageOption option;
+        if (!data.WriteInterfaceToken(GetDescriptor())) {
+            return ERROR_EX_PARCELABLE;
+        }
+
+        if (!data.WriteRemoteObject(client->AsObject().GetRefPtr())) {
+            return ERROR_EX_PARCELABLE;
+        }
+
+        auto ret = Remote()->SendRequest(STOP_INPUT, data, reply, option);
+        if (ret != NO_ERROR) {
+            return ERROR_STATUS_FAILED_TRANSACTION;
+        }
+
+        ret = reply.ReadInt32();
+        if (ret != NO_ERROR) {
+            return ret;
+        }
+
+        return NO_ERROR;
     }
 
-    auto ret = Remote()->SendRequest(RELEASE_INPUT, data, reply, option);
-    if (ret != NO_ERROR) {
-        return ERROR_STATUS_FAILED_TRANSACTION;
+    int32_t InputMethodSystemAbilityProxy::getDisplayMode(int32_t *retMode)
+    {
+        MessageParcel data, reply;
+        MessageOption option;
+
+        if (!data.WriteInterfaceToken(GetDescriptor())) {
+            return ERROR_EX_PARCELABLE;
+        }
+
+        auto ret = Remote()->SendRequest(GET_DISPLAY_MODE, data, reply, option);
+        if (ret != NO_ERROR) {
+            return ERROR_STATUS_FAILED_TRANSACTION;
+        }
+
+        ret = reply.ReadInt32();
+        if (ret != NO_ERROR) {
+            return ret;
+        }
+
+        if (!reply.ReadInt32(*retMode)) {
+            return ERROR_STATUS_BAD_VALUE;
+        }
+        return NO_ERROR;
     }
 
-    ret = reply.ReadInt32();
-    if (ret != NO_ERROR) {
-        return ret;
+    int32_t InputMethodSystemAbilityProxy::getKeyboardWindowHeight(int32_t *retHeight)
+    {
+        if (retHeight == nullptr) {
+            return ERROR_NULL_POINTER;
+        }
+
+        MessageParcel data, reply;
+        MessageOption option;
+
+        if (!data.WriteInterfaceToken(GetDescriptor())) {
+            return ERROR_EX_PARCELABLE;
+        }
+
+        auto ret = Remote()->SendRequest(GET_KEYBOARD_WINDOW_HEIGHT, data, reply, option);
+        if (ret != NO_ERROR) {
+            return ERROR_STATUS_FAILED_TRANSACTION;
+        }
+
+        ret = reply.ReadInt32();
+        if (ret != NO_ERROR) {
+            return ret;
+        }
+
+        if (!reply.ReadInt32(*retHeight)) {
+            return ERROR_STATUS_BAD_VALUE;
+        }
+        return NO_ERROR;
     }
 
-    return NO_ERROR;
-}
+    int32_t InputMethodSystemAbilityProxy::getCurrentKeyboardType(KeyboardType* retType)
+    {
+        if (retType == nullptr) {
+            return ERROR_NULL_POINTER;
+        }
 
-int32_t InputMethodSystemAbilityProxy::Start(sptr<InputClientStub> &client)
-{
-    MessageParcel data, reply;
-    MessageOption option;
-    if (!data.WriteInterfaceToken(GetDescriptor())) {
-        return ERROR_EX_PARCELABLE;
+        MessageParcel data, reply;
+        MessageOption option;
+
+        if (!data.WriteInterfaceToken(GetDescriptor())) {
+            return ERROR_EX_PARCELABLE;
+        }
+
+        auto ret = Remote()->SendRequest(GET_CURRENT_KEYBOARD_TYPE, data, reply, option);
+        if (ret != NO_ERROR) {
+            return ERROR_STATUS_FAILED_TRANSACTION;
+        }
+
+        ret = reply.ReadInt32();
+        if (ret != NO_ERROR) {
+            return ret;
+        }
+
+        KeyboardType* keyType = reply.ReadParcelable<KeyboardType>();
+        *retType = *keyType;
+        delete keyType;
+        return NO_ERROR;
     }
 
-    if (!data.WriteRemoteObject(client->AsObject().GetRefPtr())) {
-        return ERROR_EX_PARCELABLE;
-    }
-    
-    auto ret = Remote()->SendRequest(START_INPUT, data, reply, option);
-    if (ret != NO_ERROR) {
-        return ERROR_STATUS_FAILED_TRANSACTION;
+    int32_t InputMethodSystemAbilityProxy::listInputMethodEnabled(std::vector<InputMethodProperty*> *properties)
+    {
+        if (properties == nullptr) {
+            return ERROR_NULL_POINTER;
+        }
+
+        MessageParcel data, reply;
+        MessageOption option;
+
+        if (!data.WriteInterfaceToken(GetDescriptor())) {
+            return ERROR_EX_PARCELABLE;
+        }
+
+        auto ret = Remote()->SendRequest(LIST_INPUT_METHOD_ENABLED, data, reply, option);
+        if (ret != NO_ERROR) {
+            return ERROR_STATUS_FAILED_TRANSACTION;
+        }
+
+        ret = reply.ReadInt32();
+        if (ret != NO_ERROR) {
+            return ret;
+        }
+
+        auto size = reply.ReadInt32();
+        while (size > 0) {
+            InputMethodProperty* imp = reply.ReadParcelable<InputMethodProperty>();
+            properties->push_back(imp);
+            size--;
+        }
+
+        return NO_ERROR;
     }
 
-    ret = reply.ReadInt32();
-    if (ret != NO_ERROR) {
-        return ret;
+    int32_t InputMethodSystemAbilityProxy::listInputMethod(std::vector<InputMethodProperty*> *properties)
+    {
+        if (properties == nullptr) {
+            return ERROR_NULL_POINTER;
+        }
+
+        MessageParcel data, reply;
+        MessageOption option;
+
+        if (!data.WriteInterfaceToken(GetDescriptor())) {
+            return ERROR_EX_PARCELABLE;
+        }
+
+        auto ret = Remote()->SendRequest(LIST_INPUT_METHOD, data, reply, option);
+        if (ret != NO_ERROR) {
+            return ERROR_STATUS_FAILED_TRANSACTION;
+        }
+
+        ret = reply.ReadInt32();
+        if (ret != NO_ERROR) {
+            return ret;
+        }
+
+        auto size = reply.ReadInt32();
+
+        while (size > 0) {
+            InputMethodProperty* imp = reply.ReadParcelable<InputMethodProperty>();
+            properties->push_back(imp);
+            size--;
+        }
+
+        return NO_ERROR;
     }
 
-    return NO_ERROR;
-}
+    int32_t InputMethodSystemAbilityProxy::listKeyboardType(const std::u16string& imeId,
+        std::vector<KeyboardType*> *types)
+    {
+        if (types == nullptr) {
+            return ERROR_NULL_POINTER;
+        }
 
-int32_t InputMethodSystemAbilityProxy::Stop(sptr<InputClientStub> &client)
-{
-    MessageParcel data, reply;
-    MessageOption option;
-    if (!data.WriteInterfaceToken(GetDescriptor())) {
-        return ERROR_EX_PARCELABLE;
+        MessageParcel data, reply;
+        MessageOption option;
+
+        if (!(data.WriteInterfaceToken(GetDescriptor()) && data.WriteString16(imeId))) {
+            return ERROR_EX_PARCELABLE;
+        }
+
+        auto ret = Remote()->SendRequest(LIST_KEYBOARD_TYPE, data, reply, option);
+        if (ret != NO_ERROR) {
+            return ERROR_STATUS_FAILED_TRANSACTION;
+        }
+
+        ret = reply.ReadInt32();
+        if (ret != NO_ERROR) {
+            return ret;
+        }
+
+        auto size = reply.ReadInt32();
+        while (size > 0) {
+            KeyboardType* kt = reply.ReadParcelable<KeyboardType>();
+            types->push_back(kt);
+            size--;
+        }
+        return NO_ERROR;
     }
-
-    if (!data.WriteRemoteObject(client->AsObject().GetRefPtr())) {
-        return ERROR_EX_PARCELABLE;
-    }
-    
-    auto ret = Remote()->SendRequest(STOP_INPUT, data, reply, option);
-    if (ret != NO_ERROR) {
-        return ERROR_STATUS_FAILED_TRANSACTION;
-    }
-
-    ret = reply.ReadInt32();
-    if (ret != NO_ERROR) {
-        return ret;
-    }
-
-    return NO_ERROR;
-}
-
-int32_t InputMethodSystemAbilityProxy::getDisplayMode(int32_t *retMode)
-{
-    MessageParcel data, reply;
-    MessageOption option;
-
-    if (!data.WriteInterfaceToken(GetDescriptor())) {
-        return ERROR_EX_PARCELABLE;
-    }
-    
-    auto ret = Remote()->SendRequest(GET_DISPLAY_MODE, data, reply, option);
-    if (ret != NO_ERROR) {
-        return ERROR_STATUS_FAILED_TRANSACTION;
-    }
-    
-    ret = reply.ReadInt32();
-    if (ret != NO_ERROR) {
-        return ret;
-    }
-
-    if (!reply.ReadInt32(*retMode)) {
-        return ERROR_STATUS_BAD_VALUE;
-    }
-    return NO_ERROR;
-}
-
-int32_t InputMethodSystemAbilityProxy::getKeyboardWindowHeight(int32_t *retHeight)
-{
-    if (retHeight == nullptr) {
-        return ERROR_NULL_POINTER;
-    }
-
-    MessageParcel data, reply;
-    MessageOption option;
-
-    if (!data.WriteInterfaceToken(GetDescriptor())) {
-        return ERROR_EX_PARCELABLE;
-    }
-    
-    auto ret = Remote()->SendRequest(GET_KEYBOARD_WINDOW_HEIGHT, data, reply, option);
-    if (ret != NO_ERROR) {
-        return ERROR_STATUS_FAILED_TRANSACTION;
-    }
-    
-    ret = reply.ReadInt32();
-    if (ret != NO_ERROR) {
-        return ret;
-    }
-
-    if (!reply.ReadInt32(*retHeight)) {
-        return ERROR_STATUS_BAD_VALUE;
-    }
-    return NO_ERROR;
-}
-
-int32_t InputMethodSystemAbilityProxy::getCurrentKeyboardType(KeyboardType* retType)
-{
-    if (retType == nullptr) {
-        return ERROR_NULL_POINTER;
-    }
-
-    MessageParcel data, reply;
-    MessageOption option;
-
-    if (!data.WriteInterfaceToken(GetDescriptor())) {
-        return ERROR_EX_PARCELABLE;
-    }
-    
-    auto ret = Remote()->SendRequest(GET_CURRENT_KEYBOARD_TYPE, data, reply, option);
-    if (ret != NO_ERROR) {
-        return ERROR_STATUS_FAILED_TRANSACTION;
-    }
-    
-    ret = reply.ReadInt32();
-    if (ret != NO_ERROR) {
-        return ret;
-    }
-
-    KeyboardType* keyType = reply.ReadParcelable<KeyboardType>();
-    *retType = *keyType;
-    delete keyType;
-    return NO_ERROR;
-}
-
-int32_t InputMethodSystemAbilityProxy::listInputMethodEnabled(std::vector<InputMethodProperty*> *properties)
-{
-    if (properties == nullptr) {
-        return ERROR_NULL_POINTER;
-    }
-
-    MessageParcel data, reply;
-    MessageOption option;
-
-    if (!data.WriteInterfaceToken(GetDescriptor())) {
-        return ERROR_EX_PARCELABLE;
-    }
-
-    auto ret = Remote()->SendRequest(LIST_INPUT_METHOD_ENABLED, data, reply, option);
-    if (ret != NO_ERROR) {
-        return ERROR_STATUS_FAILED_TRANSACTION;
-    }
-
-    ret = reply.ReadInt32();
-    if (ret != NO_ERROR) {
-        return ret;
-    }
-
-    auto size = reply.ReadInt32();
-    while (size > 0) {
-        InputMethodProperty* imp = reply.ReadParcelable<InputMethodProperty>();
-        properties->push_back(imp);
-        size--;
-    }
-    
-    return NO_ERROR;
-}
-
-int32_t InputMethodSystemAbilityProxy::listInputMethod(std::vector<InputMethodProperty*> *properties)
-{
-    if (properties == nullptr) {
-        return ERROR_NULL_POINTER;
-    }
-
-    MessageParcel data, reply;
-    MessageOption option;
-
-    if (!data.WriteInterfaceToken(GetDescriptor())) {
-        return ERROR_EX_PARCELABLE;
-    }
-
-    auto ret = Remote()->SendRequest(LIST_INPUT_METHOD, data, reply, option);
-    if (ret != NO_ERROR) {
-        return ERROR_STATUS_FAILED_TRANSACTION;
-    }
-
-    ret = reply.ReadInt32();
-    if (ret != NO_ERROR) {
-        return ret;
-    }
-
-    auto size = reply.ReadInt32();
-
-    while (size > 0) {
-        InputMethodProperty* imp = reply.ReadParcelable<InputMethodProperty>();
-        properties->push_back(imp);
-        size--;
-    }
-    
-    return NO_ERROR;
-}
-
-int32_t InputMethodSystemAbilityProxy::listKeyboardType(const std::u16string& imeId, std::vector<KeyboardType*> *types)
-{
-    if (types == nullptr) {
-        return ERROR_NULL_POINTER;
-    }
-
-    MessageParcel data, reply;
-    MessageOption option;
-
-    if (!(data.WriteInterfaceToken(GetDescriptor()) && data.WriteString16(imeId))) {
-        return ERROR_EX_PARCELABLE;
-    }
-
-    auto ret = Remote()->SendRequest(LIST_KEYBOARD_TYPE, data, reply, option);
-    if (ret != NO_ERROR) {
-        return ERROR_STATUS_FAILED_TRANSACTION;
-    }
-
-    ret = reply.ReadInt32();
-    if (ret != NO_ERROR) {
-        return ret;
-    }
-
-    auto size = reply.ReadInt32();
-    while (size > 0) {
-        KeyboardType* kt = reply.ReadParcelable<KeyboardType>();
-        types->push_back(kt);
-        size--;
-    }
-    return NO_ERROR;
-}
 }
 }

interfaces/kits/js/napi/js_input_method_ability.cpp

@@ -191,7 +191,7 @@ napi_value InputMethodAbilityInit(napi_env env, napi_value exports)
         DECLARE_NAPI_FUNCTION("off", JS_Off),
     };
     napi_define_class(env, className, sizeof(className),JS_Constructor, nullptr,
-            sizeof(desc) / sizeof(desc[0]), desc, &constructor);
+                      sizeof(desc) / sizeof(desc[0]), desc, &constructor);
     napi_set_named_property(env, exports, "InputMethodAbility", constructor);
     return exports;
 }

services/include/global.h

@@ -34,17 +34,17 @@ using BRemoteObject = IPCObjectStub;
 #define INPUTMETHOD_DEBUG 0
 
 #define LOG_INFO(fmt, args...) \
-    LogTimeStamp();printf("I %s:%d  %s - " fmt, basename(__FILE__), __LINE__, __FUNCTION__, ##args)
+    LogTimeStamp(); printf("I %s:%d  %s - " fmt, basename(__FILE__), __LINE__, __FUNCTION__, ##args)
 
 #define LOG_ERROR(fmt, args...) \
-    LogTimeStamp();printf("E %s:%d  %s - " fmt, basename(__FILE__), __LINE__, __FUNCTION__, ##args)
+    LogTimeStamp(); printf("E %s:%d  %s - " fmt, basename(__FILE__), __LINE__, __FUNCTION__, ##args)
 
 #define LOG_WARNING(fmt, args...) \
-    LogTimeStamp();printf("W %s:%d  %s - " fmt, basename(__FILE__), __LINE__, __FUNCTION__, ##args)
+    LogTimeStamp(); printf("W %s:%d  %s - " fmt, basename(__FILE__), __LINE__, __FUNCTION__, ##args)
 
 #if DEBUG
 #define LOG_DEBUG(fmt, args...) \
-    LogTimeStamp();printf("D %s:%d  %s - " fmt, basename(__FILE__), __LINE__, __FUNCTION__, ##args)
+    LogTimeStamp(); printf("D %s:%d  %s - " fmt, basename(__FILE__), __LINE__, __FUNCTION__, ##args)
 #else
 #define LOG_DEBUG(fmt, args...)
 #endif
@@ -52,100 +52,99 @@ using BRemoteObject = IPCObjectStub;
 void LogTimeStamp();
 
 namespace CommonEvent {
-    //! the events handled in input method management system
+    // the events handled in input method management system
     enum {
-        COMMON_EVENT_USER_STARTED = 10001, /*!< a user is started. */
-        COMMON_EVENT_USER_STOPPED = 10002, /*!< a user is stopped. */
-        COMMON_EVENT_USER_UNLOCKED = 10003, /*!< a user is unlocked. */
-        COMMON_EVENT_USER_LOCKED = 10004, /*!< a user is locked. */
-        COMMON_EVENT_SETTING_CHANGED = 10005, /*!< input method setting data is changed. */
-        COMMON_EVENT_PACKAGE_ADDED = 10006, /*!< a package is installed. */
-        COMMON_EVENT_PACKAGE_REMOVED = 10007, /*!< a package is removed */
+        COMMON_EVENT_USER_STARTED = 10001, // a user is started.
+        COMMON_EVENT_USER_STOPPED = 10002, // a user is stopped.
+        COMMON_EVENT_USER_UNLOCKED = 10003, // a user is unlocked.
+        COMMON_EVENT_USER_LOCKED = 10004, // a user is locked.
+        COMMON_EVENT_SETTING_CHANGED = 10005, // input method setting data is changed.
+        COMMON_EVENT_PACKAGE_ADDED = 10006, // a package is installed.
+        COMMON_EVENT_PACKAGE_REMOVED = 10007, // a package is removed
     };
 };
 
-//! User State
+// User State
 namespace UserState {
-    /*! The states of a user in the system. */
+    /*! The states of a user in the system.
     enum {
         USER_STATE_NOT_AVAILABLE = -1,
-        USER_STATE_STARTED = 0, /*!< a user is started. */
-        USER_STATE_UNLOCKED, /*!< a user is unlocked. */
+        USER_STATE_STARTED = 0, // a user is started.
+        USER_STATE_UNLOCKED, // a user is unlocked.
     };
 };
 
-//! Error Code
+// Error Code
 namespace ErrorCode {
-    /*! Error Code definition in the input method management system */
+    /*! Error Code definition in the input method management system
     enum {
-        ERROR_STATUS_UNKNOWN_ERROR = (-2147483647 - 1), //!< unknown error
-        ERROR_STATUS_NO_MEMORY = -ENOMEM, //!< no memory
-        ERROR_STATUS_INVALID_OPERATION = -ENOSYS, //!< invalid operation
-        ERROR_STATUS_BAD_VALUE = -EINVAL, //!< bad value
-        ERROR_STATUS_BAD_TYPE = ERROR_STATUS_UNKNOWN_ERROR+1, //!< bad type
-        ERROR_STATUS_NAME_NOT_FOUND = -ENOENT, //!< name not found
-        ERROR_STATUS_PERMISSION_DENIED = -EPERM, //!< permission denied
-        ERROR_STATUS_NO_INIT = -ENODEV, //!<  no init
-        ERROR_STATUS_ALREADY_EXISTS = -EEXIST,  //!<  already exist
-        ERROR_STATUS_DEAD_OBJECT = -EPIPE, //!< dead object
-        ERROR_STATUS_FAILED_TRANSACTION = ERROR_STATUS_UNKNOWN_ERROR+2, //!< failed transaction
-        ERROR_STATUS_BAD_INDEX = -EOVERFLOW, //!< bad index
-        ERROR_STATUS_NOT_ENOUGH_DATA = -ENODATA, //!<  not enough data
-        ERROR_STATUS_WOULD_BLOCK = -EWOULDBLOCK, //!< would block
-        ERROR_STATUS_TIMED_OUT = -ETIMEDOUT, //!< time out
-        ERROR_STATUS_UNKNOWN_TRANSACTION = -EBADMSG, //!< unknown transaction
-        ERROR_STATUS_FDS_NOT_ALLOWED = ERROR_STATUS_UNKNOWN_ERROR+7, //!< fds not allowed
-        ERROR_STATUS_UNEXPECTED_NULL = ERROR_STATUS_UNKNOWN_ERROR+8, //!< unexpected null,
+        ERROR_STATUS_UNKNOWN_ERROR = (-2147483647 - 1), // unknown error
+        ERROR_STATUS_NO_MEMORY = -ENOMEM, // no memory
+        ERROR_STATUS_INVALID_OPERATION = -ENOSYS, // invalid operation
+        ERROR_STATUS_BAD_VALUE = -EINVAL, // bad value
+        ERROR_STATUS_BAD_TYPE = ERROR_STATUS_UNKNOWN_ERROR + 1, // bad type
+        ERROR_STATUS_NAME_NOT_FOUND = -ENOENT, // name not found
+        ERROR_STATUS_PERMISSION_DENIED = -EPERM, // permission denied
+        ERROR_STATUS_NO_INIT = -ENODEV, //  no init
+        ERROR_STATUS_ALREADY_EXISTS = -EEXIST,  //  already exist
+        ERROR_STATUS_DEAD_OBJECT = -EPIPE, // dead object
+        ERROR_STATUS_FAILED_TRANSACTION = ERROR_STATUS_UNKNOWN_ERROR + 2, // failed transaction
+        ERROR_STATUS_BAD_INDEX = -EOVERFLOW, // bad index
+        ERROR_STATUS_NOT_ENOUGH_DATA = -ENODATA, // not enough data
+        ERROR_STATUS_WOULD_BLOCK = -EWOULDBLOCK, // would block
+        ERROR_STATUS_TIMED_OUT = -ETIMEDOUT, // time out
+        ERROR_STATUS_UNKNOWN_TRANSACTION = -EBADMSG, // unknown transaction
+        ERROR_STATUS_FDS_NOT_ALLOWED = ERROR_STATUS_UNKNOWN_ERROR + 7, // fds not allowed
+        ERROR_STATUS_UNEXPECTED_NULL = ERROR_STATUS_UNKNOWN_ERROR + 8, // unexpected null,
 
         // binder exception error code from Status.h
-        ERROR_EX_ILLEGAL_ARGUMENT = -3, //!< illegal argument exception
-        ERROR_EX_NULL_POINTER = -4, //!< null pointer exception
-        ERROR_EX_ILLEGAL_STATE = -5, //!< illegal state exception
-        ERROR_EX_NETWORK_MAIN_THREAD = -6, //!< network main thread exception
-        ERROR_EX_UNSUPPORTED_OPERATION = -7, //!< unsupported operation exception
-        ERROR_EX_SERVICE_SPECIFIC = -8, //!< service specific exception
-        ERROR_EX_PARCELABLE = -9, //!< parcelable exception
+        ERROR_EX_ILLEGAL_ARGUMENT = -3, // illegal argument exception
+        ERROR_EX_NULL_POINTER = -4, // null pointer exception
+        ERROR_EX_ILLEGAL_STATE = -5, // illegal state exception
+        ERROR_EX_NETWORK_MAIN_THREAD = -6, // network main thread exception
+        ERROR_EX_UNSUPPORTED_OPERATION = -7, // unsupported operation exception
+        ERROR_EX_SERVICE_SPECIFIC = -8, // service specific exception
+        ERROR_EX_PARCELABLE = -9, // parcelable exception
         // no error
-        NO_ERROR = 0, //!< no error
+        NO_ERROR = 0, // no error
 
         // system service error
-        ERROR_NULL_POINTER, //!< null pointer
-        ERROR_BAD_PARAMETERS,  //!< bad parameters
-        ERROR_SERVICE_START_FAILED, //!< failed to start service
-        ERROR_USER_NOT_STARTED, //!< user is not started
-        ERROR_USER_ALREADY_STARTED, //!< user has already started
-        ERROR_USER_NOT_UNLOCKED, //!< user is not unlocked
-        ERROR_USER_ALREADY_UNLOCKED, //!< user has already unlocked
-        ERROR_USER_NOT_LOCKED, //!< user is not locked
+        ERROR_NULL_POINTER, // null pointer
+        ERROR_BAD_PARAMETERS,  // bad parameters
+        ERROR_SERVICE_START_FAILED, // failed to start service
+        ERROR_USER_NOT_STARTED, // user is not started
+        ERROR_USER_ALREADY_STARTED, // user has already started
+        ERROR_USER_NOT_UNLOCKED, // user is not unlocked
+        ERROR_USER_ALREADY_UNLOCKED, // user has already unlocked
+        ERROR_USER_NOT_LOCKED, // user is not locked
 
-        ERROR_IME_NOT_AVAILABLE, //!< input method engine is not available
-        ERROR_SECURITY_IME_NOT_AVAILABLE, //!< security input method engine is not available
-	    ERROR_TOKEN_CREATE_FAILED, //!< failed to create window token
-	    ERROR_TOKEN_DESTROY_FAILED, //!< failed to destroy window token
-        ERROR_IME_BIND_FAILED, //!< failed to bind IME service
-        ERROR_IME_UNBIND_FAILED, //!< failed to unbind IME service
-        ERROR_IME_START_FAILED, //!< failed to start IME service
-        ERROR_IME_STOP_FAILED, //!< failed to stop IME service
-        ERROR_KBD_SHOW_FAILED, //!< failed to show keyboard
-        ERROR_KBD_HIDE_FAILED, //!< failed to hide keyboard
-        ERROR_IME_NOT_STARTED, //!< input method service is not started
-        ERROR_KBD_IS_OCCUPIED, //!< keyboard is showing by other client
-        ERROR_KBD_IS_NOT_SHOWING, //!< keyboard is not showing
-        ERROR_IME_ALREADY_STARTED, //!< input method service has already started
-        ERROR_NOT_IME_PACKAGE, //!< not an IME package
-        ERROR_IME_PACKAGE_DUPLICATED, //!< duplicated IME package
-        ERROR_SETTING_SAME_VALUE, //!< same setting value
-        ERROR_NO_NEXT_IME, //!< no next ime is available
-        ERROR_CLIENTWINDOW_NOT_FOCUSED, //!< the input client window is not focused
-        ERROR_CLIENT_NOT_WINDOW, //!< the input client is not from a valid window
+        ERROR_IME_NOT_AVAILABLE, // input method engine is not available
+        ERROR_SECURITY_IME_NOT_AVAILABLE, // security input method engine is not available
+        ERROR_TOKEN_CREATE_FAILED, // failed to create window token
+        ERROR_TOKEN_DESTROY_FAILED, // failed to destroy window token
+        ERROR_IME_BIND_FAILED, // failed to bind IME service
+        ERROR_IME_UNBIND_FAILED, // failed to unbind IME service
+        ERROR_IME_START_FAILED, // failed to start IME service
+        ERROR_IME_STOP_FAILED, // failed to stop IME service
+        ERROR_KBD_SHOW_FAILED, // failed to show keyboard
+        ERROR_KBD_HIDE_FAILED, // failed to hide keyboard
+        ERROR_IME_NOT_STARTED, // input method service is not started
+        ERROR_KBD_IS_OCCUPIED, // keyboard is showing by other client
+        ERROR_KBD_IS_NOT_SHOWING, // keyboard is not showing
+        ERROR_IME_ALREADY_STARTED, // input method service has already started
+        ERROR_NOT_IME_PACKAGE, // not an IME package
+        ERROR_IME_PACKAGE_DUPLICATED, // duplicated IME package
+        ERROR_SETTING_SAME_VALUE, // same setting value
+        ERROR_NO_NEXT_IME, // no next ime is available
+        ERROR_CLIENTWINDOW_NOT_FOCUSED, // the input client window is not focused
+        ERROR_CLIENT_NOT_WINDOW, // the input client is not from a valid window
         // error from ime
-        ERROR_REMOTE_IME_DIED, //!< remote input method service died abnormally
-        ERROR_RESTART_IME_FAILED, //!< failed to restart input method service
+        ERROR_REMOTE_IME_DIED, // remote input method service died abnormally
+        ERROR_RESTART_IME_FAILED, // failed to restart input method service
         // error from client
-        ERROR_REMOTE_CLIENT_DIED,  //!< remote client died abnormally
-        ERROR_CLIENT_DUPLICATED,  //!< duplicated client
-        ERROR_CLIENT_NOT_FOUND, //!< client is not found
-
+        ERROR_REMOTE_CLIENT_DIED,  // remote client died abnormally
+        ERROR_CLIENT_DUPLICATED,  // duplicated client
+        ERROR_CLIENT_NOT_FOUND, // client is not found
     };
     const char* ToString(int errorCode);
 };
@@ -166,7 +165,6 @@ static constexpr HiviewDFX::HiLogLabel g_SMALL_SERVICES_LABEL = {
     "line: %d, function: %s," fmt, __LINE__, __FUNCTION__, ##__VA_ARGS__)
 #define IMSA_HILOGW(fmt, ...) (void)OHOS::HiviewDFX::HiLog::Warn(OHOS::MiscServices::g_SMALL_SERVICES_LABEL, \
     "line: %d, function: %s," fmt, __LINE__, __FUNCTION__, ##__VA_ARGS__)
-
 }
 }
 #endif // FM_IMMS_PROJECT_GLOBAL_H

services/include/i_input_control_channel.h

@@ -43,5 +43,4 @@ namespace OHOS {
         };
     }
 }
-
 #endif // FM_IMMS_PROJECT_IINPUTCONTROLCHANNEL_H

services/include/i_input_method_proxy.h

@@ -34,5 +34,4 @@ namespace OHOS {
         };
     }
 }
-
 #endif // FM_IMMS_PROJECT_IINPUTMETHODAGENT_H

services/include/i_input_method_system_ability.h

@@ -30,38 +30,37 @@
 
 namespace OHOS {
 namespace MiscServices {
-class IInputMethodSystemAbility : public IRemoteBroker {
-public:
-    enum {
-        PREPARE_INPUT = 0,
-        RELEASE_INPUT,
-        START_INPUT,
-        STOP_INPUT,
-        SET_INPUT_METHOD_CORE,
-        GET_DISPLAY_MODE,
-        GET_KEYBOARD_WINDOW_HEIGHT,
-        GET_CURRENT_KEYBOARD_TYPE,
-        LIST_INPUT_METHOD_ENABLED,
-        LIST_INPUT_METHOD,
-        LIST_KEYBOARD_TYPE,
+    class IInputMethodSystemAbility : public IRemoteBroker {
+    public:
+        enum {
+            PREPARE_INPUT = 0,
+            RELEASE_INPUT,
+            START_INPUT,
+            STOP_INPUT,
+            SET_INPUT_METHOD_CORE,
+            GET_DISPLAY_MODE,
+            GET_KEYBOARD_WINDOW_HEIGHT,
+            GET_CURRENT_KEYBOARD_TYPE,
+            LIST_INPUT_METHOD_ENABLED,
+            LIST_INPUT_METHOD,
+            LIST_KEYBOARD_TYPE,
+        };
+
+        DECLARE_INTERFACE_DESCRIPTOR(u"ohos.miscservices.inputmethod.IInputMethodSystemAbility");
+
+        virtual void prepareInput(MessageParcel& data) = 0;
+        virtual void releaseInput(MessageParcel& data) = 0;
+        virtual void startInput(MessageParcel& data) = 0;
+        virtual void stopInput(MessageParcel& data) = 0;
+        virtual int32_t setInputMethodCore(sptr<IInputMethodCore> &core)=0;
+
+        virtual int32_t getDisplayMode(int32_t *retMode) = 0;
+        virtual int32_t getKeyboardWindowHeight(int32_t *retHeight) = 0;
+        virtual int32_t getCurrentKeyboardType(KeyboardType* retType) = 0;
+        virtual int32_t listInputMethodEnabled(std::vector<InputMethodProperty*> *properties) = 0;
+        virtual int32_t listInputMethod(std::vector<InputMethodProperty*> *properties) = 0;
+        virtual int32_t listKeyboardType(const std::u16string& imeId, std::vector<KeyboardType*> *types) = 0;
     };
-
-    DECLARE_INTERFACE_DESCRIPTOR(u"ohos.miscservices.inputmethod.IInputMethodSystemAbility");
-
-    virtual void prepareInput(MessageParcel& data) = 0;
-    virtual void releaseInput(MessageParcel& data) = 0;
-    virtual void startInput(MessageParcel& data) = 0;
-    virtual void stopInput(MessageParcel& data) = 0;
-    virtual int32_t setInputMethodCore(sptr<IInputMethodCore> &core)=0;
-
-    virtual int32_t getDisplayMode(int32_t *retMode) = 0;
-    virtual int32_t getKeyboardWindowHeight(int32_t *retHeight) = 0;
-    virtual int32_t getCurrentKeyboardType(KeyboardType* retType) = 0;
-    virtual int32_t listInputMethodEnabled(std::vector<InputMethodProperty*> *properties) = 0;
-    virtual int32_t listInputMethod(std::vector<InputMethodProperty*> *properties) = 0;
-    virtual int32_t listKeyboardType(const std::u16string& imeId, std::vector<KeyboardType*> *types) = 0;
-};
 }
 }
-
 #endif // FM_IMMS_PROJECT_IINPUTMETHODSYSTEMABILITY_H

services/include/i_platform_api.h

@@ -51,7 +51,7 @@ namespace OHOS {
         virtual int32_t unbindInputMethodService(int userId, const std::u16string& packageName) = 0;
         virtual sptr<IRemoteObject> createWindowToken(int userId, int displayId, const std::u16string& packageName) = 0;
         virtual int32_t destroyWindowToken(int userId, const std::u16string& packageName) = 0;
-        virtual int32_t listInputMethod(int userId, std::vector<InputMethodProperty*> *inputMethodProperties) = 0;
+        virtual int32_t listInputMethod(int userId, std::vector<InputMethodProperty*> *properties) = 0;
         virtual int32_t getInputMethodProperty(int userId, const std::u16string& packageName,
                                                 InputMethodProperty *inputMethodProperty) = 0;
         virtual int32_t getInputMethodSetting(int userId, InputMethodSetting *inputMethodSetting) = 0;

services/include/input_attribute.h

@@ -19,23 +19,23 @@
 
 namespace OHOS {
 namespace MiscServices {
-class InputAttribute : public Parcelable {
-public:
-    InputAttribute();
-    InputAttribute(const InputAttribute& attribute);
-    InputAttribute& operator=(const InputAttribute& attribute);
-    ~InputAttribute();
-    virtual bool Marshalling(Parcel &parcel) const override;
-    static InputAttribute *Unmarshalling(Parcel &parcel);
-    void SetInputPattern(int32_t pattern);
-    bool GetSecurityFlag();
-    static const int32_t PATTERN_TEXT = 0x00000001;
-    static const int32_t PATTERN_PASSWORD = 0x00000007;
-private:
-    int32_t inputPattern;
-    int32_t enterKeyType;
-    int32_t inputOption;
-};
+    class InputAttribute : public Parcelable {
+    public:
+        InputAttribute();
+        InputAttribute(const InputAttribute& attribute);
+        InputAttribute& operator=(const InputAttribute& attribute);
+        ~InputAttribute();
+        virtual bool Marshalling(Parcel &parcel) const override;
+        static InputAttribute *Unmarshalling(Parcel &parcel);
+        void SetInputPattern(int32_t pattern);
+        bool GetSecurityFlag();
+        static const int32_t PATTERN_TEXT = 0x00000001;
+        static const int32_t PATTERN_PASSWORD = 0x00000007;
+    private:
+        int32_t inputPattern;
+        int32_t enterKeyType;
+        int32_t inputOption;
+    };
 }
 }
 

services/include/input_channel.h

@@ -22,7 +22,7 @@
 
 namespace OHOS {
 namespace MiscServices {
-    class InputChannel : public Parcelable{
+    class InputChannel : public Parcelable {
     public:
         InputChannel();
         ~InputChannel();
@@ -33,7 +33,7 @@ namespace MiscServices {
         MessageParcel inputChannelParcel;
         InputChannel(const InputChannel& channel);
         InputChannel& operator=(const InputChannel& channel);
-  };
+    };
 }
 }
 #endif // INPUTMETHODSYSTEMSERVICE_INPUTCHANNEL_H

services/include/input_control_channel_proxy.h

@@ -41,6 +41,4 @@ namespace MiscServices {
     };
 }
 }
-#endif // FM_IMMS_PROJECT_INPUTCONTROLCHANNELPROXY_H
-
-
+#endif // FM_IMMS_PROJECT_INPUTCONTROLCHANNELPROXY_H

services/include/input_control_channel_stub.h

@@ -53,7 +53,7 @@ namespace OHOS {
         std::condition_variable cv;
         bool agentReadyFlag = false;
         bool keyboardReadyFlag = false;
-  };
+    };
 }
 }
 #endif // FM_IMMS_PROJECT_INPUTCONTROLCHANNEL_SK_H

services/include/input_method_ability_connection_stub.h

@@ -32,11 +32,11 @@ namespace OHOS {
 
                 InputMethodAbilityConnectionStub(const int index);
                 ~InputMethodAbilityConnectionStub();
-                void OnAbilityConnectDone(const AppExecFwk::ElementName &element, const sptr<IRemoteObject> &remoteObject, int resultCode) override;
+                void OnAbilityConnectDone(const AppExecFwk::ElementName &element,
+                                          const sptr<IRemoteObject> &remoteObject, int resultCode) override;
                 void OnAbilityDisconnectDone(const AppExecFwk::ElementName &element, int resultCode) override;
                 void SetHandler(MessageHandler* handler);
 
-
             private:
                 MessageHandler* messageHandler;
                 int mIndex;

services/include/input_method_property.h

@@ -22,23 +22,23 @@
 
 namespace OHOS {
 namespace MiscServices {
-class InputMethodProperty : public Parcelable {
-public:
-    std::u16string mImeId;
-    std::u16string mPackageName;
-    std::u16string mAbilityName;
-    std::u16string mConfigurationPage;
-    bool isSystemIme;
-    int32_t mDefaultImeId;
-    std::vector<KeyboardType*> mTypes;
+    class InputMethodProperty : public Parcelable {
+    public:
+        std::u16string mImeId;
+        std::u16string mPackageName;
+        std::u16string mAbilityName;
+        std::u16string mConfigurationPage;
+        bool isSystemIme;
+        int32_t mDefaultImeId;
+        std::vector<KeyboardType*> mTypes;
 
-    InputMethodProperty();
-    ~InputMethodProperty();
-    InputMethodProperty(const InputMethodProperty& property);
-    InputMethodProperty& operator=(const InputMethodProperty& property);
-    virtual bool Marshalling(Parcel &parcel) const override;
-    static InputMethodProperty *Unmarshalling(Parcel &parcel);
-};
+        InputMethodProperty();
+        ~InputMethodProperty();
+        InputMethodProperty(const InputMethodProperty& property);
+        InputMethodProperty& operator=(const InputMethodProperty& property);
+        virtual bool Marshalling(Parcel &parcel) const override;
+        static InputMethodProperty *Unmarshalling(Parcel &parcel);
+    };
 }
 }
 #endif // FM_IMMS_PROJECT_INPUTMETHODPROPERTY_H

services/include/input_method_setting.h

@@ -26,13 +26,11 @@ namespace MiscServices {
     class InputMethodSetting : public Parcelable {
     public:
 
-        const static std::u16string CURRENT_INPUT_METHOD_TAG; //!< the item name of 'default IME' in the system setting
-        const static std::u16string ENABLED_INPUT_METHODS_TAG; //!< the item name of 'enabled IME list' in the system setting
-        const static std::u16string CURRENT_KEYBOARD_TYPE_TAG; //!< the item name of 'default keyboard type' in the system setting
-        const static std::u16string CURRENT_SYS_KEYBOARD_TYPE_TAG;
-        //!< the item name of 'default keyboard type for security IME in the system setting
-
-        const static std::u16string SYSTEM_LOCALE_TAG;  //!< the item name of locale list supported in the system
+        const static std::u16string CURRENT_INPUT_METHOD_TAG; // default IME
+        const static std::u16string ENABLED_INPUT_METHODS_TAG; // enabled IME list
+        const static std::u16string CURRENT_KEYBOARD_TYPE_TAG; // default keyboard type
+        const static std::u16string CURRENT_SYS_KEYBOARD_TYPE_TAG; // default keyboard type for security IME
+        const static std::u16string SYSTEM_LOCALE_TAG;  // locale list supported in the system
 
 
         InputMethodSetting();

services/include/input_method_system_ability.h

@@ -43,7 +43,8 @@ namespace MiscServices {
         
         int32_t GetUserState(int32_t userId);
 
-        int32_t OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) override;
+        int32_t OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply,
+                                MessageOption &option) override;
         virtual int32_t getDisplayMode(int32_t *retMode) override;
         virtual int32_t getKeyboardWindowHeight(int32_t *retHeight) override;
         virtual int32_t getCurrentKeyboardType(KeyboardType* retType) override;

services/include/input_method_system_ability_stub.h

@@ -24,18 +24,18 @@
 
 namespace OHOS {
 namespace MiscServices {
-class InputMethodSystemAbilityStub : public IRemoteStub<IInputMethodSystemAbility> {
-public:
-    int32_t OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) override;
+    class InputMethodSystemAbilityStub : public IRemoteStub<IInputMethodSystemAbility> {
+    public:
+        int32_t OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) override;
 
-    virtual void prepareInput(MessageParcel& data) override;
-    virtual void releaseInput(MessageParcel& data) override;
-    virtual void startInput(MessageParcel& data) override;
-    virtual void stopInput(MessageParcel& data) override;
-    void setInputMethodCoreFromHap(MessageParcel& data);
-protected:
-    int32_t getUserId(int32_t uid);
-};
+        virtual void prepareInput(MessageParcel& data) override;
+        virtual void releaseInput(MessageParcel& data) override;
+        virtual void startInput(MessageParcel& data) override;
+        virtual void stopInput(MessageParcel& data) override;
+        void setInputMethodCoreFromHap(MessageParcel& data);
+    protected:
+        int32_t getUserId(int32_t uid);
+    };
 }
 }
 

services/include/keyboard_type.h

@@ -22,42 +22,42 @@
 
 namespace OHOS {
 namespace MiscServices {
-class KeyboardType : public Parcelable {
-public:
-    KeyboardType();
-    KeyboardType(const KeyboardType& type);
-    ~KeyboardType();
-    KeyboardType& operator=(const KeyboardType& type);
-    virtual bool Marshalling(Parcel &parcel) const override;
-    static KeyboardType *Unmarshalling(Parcel &parcel);
-    void setId(int32_t typeId);
-    void setLabelId(int32_t labelId);
-    void setIconId(int32_t iconId);
-    void setAsciiCapability(bool isAsciiCapable);
-    void setLanguage(std::u16string language);
-    void setInputSource(std::u16string inputSource);
-    void setCustomizedValue(std::u16string keyBoardTypeCustomizedValue);
-    int32_t getId() const;
-    int32_t getLabelId() const;
-    int32_t getIconId() const;
-    int32_t getHashCode() const;
-    std::u16string getLanguage() const;
-    std::u16string getInputSource() const;
-    std::u16string getCustomizedValue() const;
-    bool supportsAscii();
+    class KeyboardType : public Parcelable {
+    public:
+        KeyboardType();
+        KeyboardType(const KeyboardType& type);
+        ~KeyboardType();
+        KeyboardType& operator=(const KeyboardType& type);
+        virtual bool Marshalling(Parcel &parcel) const override;
+        static KeyboardType *Unmarshalling(Parcel &parcel);
+        void setId(int32_t typeId);
+        void setLabelId(int32_t labelId);
+        void setIconId(int32_t iconId);
+        void setAsciiCapability(bool isAsciiCapable);
+        void setLanguage(std::u16string language);
+        void setInputSource(std::u16string inputSource);
+        void setCustomizedValue(std::u16string customizedValue);
+        int32_t getId() const;
+        int32_t getLabelId() const;
+        int32_t getIconId() const;
+        int32_t getHashCode() const;
+        std::u16string getLanguage() const;
+        std::u16string getInputSource() const;
+        std::u16string getCustomizedValue() const;
+        bool supportsAscii();
 
-private:
-    int32_t mId;
-    int32_t mHashCode;
-    int32_t mLabelId;
-    int32_t mIconId;
-    bool mIsAsciiCapable;
-    std::u16string mLanguage;
-    std::u16string mInputSource;
-    std::u16string mCustomizedValue;
+    private:
+        int32_t mId;
+        int32_t mHashCode;
+        int32_t mLabelId;
+        int32_t mIconId;
+        bool mIsAsciiCapable;
+        std::u16string mLanguage;
+        std::u16string mInputSource;
+        std::u16string mCustomizedValue;
 
-    const int32_t ID_NONE = 0;
-};
+        const int32_t ID_NONE = 0;
+    };
 }
 }
 #endif // FM_IMMS_PROJECT_KEYBOARDTYPE_H

services/include/message.h

@@ -21,18 +21,18 @@
 #include "message_parcel.h"
 namespace OHOS {
 namespace MiscServices {
-class Message {
-public:
-    int32_t msgId_; //!< message id
-    MessageParcel *msgContent_ = nullptr; //!< message content
-    Message(int32_t msgId, MessageParcel* msgContent);
-    explicit Message(const Message& msg);
-    Message& operator= (const Message& msg);
-    ~Message();
-private:
-    Message(const Message&&);
-    Message& operator= (const Message&&);
-};
+    class Message {
+    public:
+        int32_t msgId_; // message id
+        MessageParcel *msgContent_ = nullptr; // message content
+        Message(int32_t msgId, MessageParcel* msgContent);
+        explicit Message(const Message& msg);
+        Message& operator= (const Message& msg);
+        ~Message();
+    private:
+        Message(const Message&&);
+        Message& operator= (const Message&&);
+    };
 }
 }
 

services/include/message_handler.h

@@ -29,34 +29,34 @@ namespace MiscServices {
 namespace MessageID {
     enum {
         // for system broadcast
-        MSG_ID_SYSTEM_START = 0, //!< system started
-        MSG_ID_SYSTEM_STOP, //!< system stopped
-        MSG_ID_USER_START, //!<  a user started
-        MSG_ID_USER_STOP, //!< a user stopped
-        MSG_ID_USER_UNLOCK, //!< a user unlocked
-        MSG_ID_USER_LOCK, //!< a user locked
-        MSG_ID_PACKAGE_ADDED, //!< a package is installed
-        MSG_ID_PACKAGE_REMOVED, //!< a package is removed
-        MSG_ID_SETTING_CHANGED, //!< input method setting is changed
+        MSG_ID_SYSTEM_START = 0, // system started
+        MSG_ID_SYSTEM_STOP, // system stopped
+        MSG_ID_USER_START, //  a user started
+        MSG_ID_USER_STOP, // a user stopped
+        MSG_ID_USER_UNLOCK, // a user unlocked
+        MSG_ID_USER_LOCK, // a user locked
+        MSG_ID_PACKAGE_ADDED, // a package is installed
+        MSG_ID_PACKAGE_REMOVED, // a package is removed
+        MSG_ID_SETTING_CHANGED, // input method setting is changed
 
         // the request from client
-        MSG_ID_PREPARE_INPUT, //!< prepare input
-        MSG_ID_START_INPUT, //!< start input
-        MSG_ID_STOP_INPUT, //!< stop input
-        MSG_ID_RELEASE_INPUT, //!< release input
+        MSG_ID_PREPARE_INPUT, // prepare input
+        MSG_ID_START_INPUT, // start input
+        MSG_ID_STOP_INPUT, // stop input
+        MSG_ID_RELEASE_INPUT, // release input
         MSG_ID_SET_INPUT_METHOD_CORE,
 
         // the request to handle the condition that the remote object died
-        MSG_ID_CLIENT_DIED, //!< input client died
-        MSG_ID_IMS_DIED, //!< input method service died
-        MSG_ID_DISABLE_IMS, //!< disable input method service
-        MSG_ID_RESTART_IMS, //!< restart input method service
-        MSG_ID_HIDE_KEYBOARD_SELF, //!< hide the current keyboard
-        MSG_ID_ADVANCE_TO_NEXT, //!< switch to next
-        MSG_ID_SET_DISPLAY_MODE, //!< set display mode
+        MSG_ID_CLIENT_DIED, // input client died
+        MSG_ID_IMS_DIED, // input method service died
+        MSG_ID_DISABLE_IMS, // disable input method service
+        MSG_ID_RESTART_IMS, // restart input method service
+        MSG_ID_HIDE_KEYBOARD_SELF, // hide the current keyboard
+        MSG_ID_ADVANCE_TO_NEXT, // switch to next
+        MSG_ID_SET_DISPLAY_MODE, // set display mode
 
-        MSG_ID_SHELL_COMMAND, //!< shell command
-        MSG_ID_EXIT_SERVICE, //!< exit service
+        MSG_ID_SHELL_COMMAND, // shell command
+        MSG_ID_EXIT_SERVICE, // exit service
 
         //the request from IMSA to IMC
         MSG_ID_INSERT_CHAR,
@@ -65,36 +65,35 @@ namespace MessageID {
         MSG_ID_ON_INPUT_READY,
 
         // the request from IMSA to IMA
-        MSG_ID_SHOW_KEYBOARD, //
-        MSG_ID_INITIALIZE_INPUT, //
-        MSG_ID_HIDE_KEYBOARD, //
+        MSG_ID_SHOW_KEYBOARD,
+        MSG_ID_INITIALIZE_INPUT,
+        MSG_ID_HIDE_KEYBOARD,
         MSG_ID_SET_KEYBOARD_TYPE,
         MSG_ID_GET_KEYBOARD_WINDOW_HEIGHT,
-        
+
         // the request from IMC to IMA
-        MSG_ID_DISPATCH_KEY,//!< dispatch key from PhysicalKbd 
+        MSG_ID_DISPATCH_KEY, // dispatch key from PhysicalKbd
     };
 }
 
 class MessageHandler {
-public:
-    MessageHandler();
-    ~MessageHandler();
-    void SendMessage(Message* msg);
-    Message* GetMessage();
-    static MessageHandler* Instance();
+    public:
+        MessageHandler();
+        ~MessageHandler();
+        void SendMessage(Message* msg);
+        Message* GetMessage();
+        static MessageHandler* Instance();
 
-private:
-    std::mutex mMutex; //!< a mutex to guard message queue
-    std::condition_variable mCV; //!< condition variable to work with mMutex
-    std::queue<Message*> mQueue ;//!< Message queue, guarded by mMutex;
+    private:
+        std::mutex mMutex; // a mutex to guard message queue
+        std::condition_variable mCV; // condition variable to work with mMutex
+        std::queue<Message*> mQueue ; // Message queue, guarded by mMutex;
 
-    MessageHandler(const MessageHandler&);
-    MessageHandler& operator= (const MessageHandler&);
-    MessageHandler(const MessageHandler&&);
-    MessageHandler& operator= (const MessageHandler&&);
-};
+        MessageHandler(const MessageHandler&);
+        MessageHandler& operator= (const MessageHandler&);
+        MessageHandler(const MessageHandler&&);
+        MessageHandler& operator= (const MessageHandler&&);
+    };
 }
 }
-
 #endif // FM_IMMS_PROJECT_MESSAGEHANDLER_H

services/include/peruser_session.h

@@ -47,9 +47,9 @@ namespace MiscServices {
             RemoteObjectDeathRecipient(int userId, int msgId);
             ~RemoteObjectDeathRecipient();
             void OnRemoteDied(const wptr<IRemoteObject>& who) override;
-        private :
-            int userId_; //!< the id of the user to whom the object is linking
-            int msgId_; //!< the message id can be  MessageID::MSG_ID_CLIENT_DIED and MessageID::MSG_ID_IMS_DIED
+        private:
+            int userId_; // the id of the user to whom the object is linking
+            int msgId_; // the message id can be  MessageID::MSG_ID_CLIENT_DIED and MessageID::MSG_ID_IMS_DIED
         };
 
     /*! \class ClientInfo
@@ -57,13 +57,13 @@ namespace MiscServices {
     */
     class ClientInfo {
         public:
-            int pid; //!< the process id of the process in which the input client is running
-            int uid; //!< the uid of the process in which the input client is running
-            int userId; //!< the user if of the user under which the input client is running
-            int displayId; //!< the display id on which the input client is showing
-            sptr<IInputClient> client; //!< the remote object handler for the service to callback to the input client
-            sptr<IInputDataChannel> channel; //!< the remote object handler for input method service callback to input client
-            InputAttribute attribute; //!< the input attribute of the input client
+            int pid; // the process id of the process in which the input client is running
+            int uid; // the uid of the process in which the input client is running
+            int userId; // the user if of the user under which the input client is running
+            int displayId; // the display id on which the input client is showing
+            sptr<IInputClient> client; // the remote object handler for the service to callback to the input client
+            sptr<IInputDataChannel> channel; // the remote object handler for IMSA callback to input client
+            InputAttribute attribute; // the input attribute of the input client
 
         ClientInfo(int pid, int uid, int userId, int displayId, const sptr<IInputClient>& client,
                    const sptr<IInputDataChannel>& channel, const InputAttribute& attribute)
@@ -91,9 +91,9 @@ namespace MiscServices {
     */
     class PerUserSession {
         enum {
-            DEFAULT_IME = 0,  //!< index for default input method service
-            SECURITY_IME = 1, //!< index for security input method service
-            MAX_IME = 2, //!< the maximum count of ims started for a user
+            DEFAULT_IME = 0,  // index for default input method service
+            SECURITY_IME = 1, // index for security input method service
+            MAX_IME = 2, // the maximum count of ims started for a user
         };
 
         public:
@@ -117,33 +117,33 @@ namespace MiscServices {
             void SetInputMethodAbility(sptr<InputMethodAbility> &inputMethodAbility);
             static void BindInputAbility();
         private:
-            int userId_; //!< the id of the user to whom the object is linking
-            int userState; //!< the state of the user to whom the object is linking
-            int displayId; //!< the id of the display screen on which the user is
+            int userId_; // the id of the user to whom the object is linking
+            int userState; // the state of the user to whom the object is linking
+            int displayId; // the id of the display screen on which the user is
             int currentIndex;
-            std::map<sptr<IRemoteObject>, ClientInfo*> mapClients; //!< a map to manage the input clients connected to the service
+            std::map<sptr<IRemoteObject>, ClientInfo*> mapClients;
 
-            InputMethodProperty* currentIme[MAX_IME]; //!< 0 - the default ime. 1 - security ime
+            InputMethodProperty* currentIme[MAX_IME]; // 0 - the default ime. 1 - security ime
 
-            InputControlChannelStub* localControlChannel[MAX_IME]; //!< inputControlChannel object used by the local process
-            sptr<IInputControlChannel> inputControlChannel[MAX_IME]; //!< channels between the service and input method service
-            sptr<IInputMethodCore> imsCore[MAX_IME]; //!< the remote handlers of input method service
-            sptr<IRemoteObject> inputMethodToken[MAX_IME]; //!< the window token of keyboard
-            int currentKbdIndex[MAX_IME]; //!< current keyboard index
-            int lastImeIndex; //!< The last ime which showed keyboard
-            InputMethodSetting* inputMethodSetting; //!< The pointer referred to the object in PerUserSetting
-            int currentDisplayMode; //!< the display mode of the current keyboard
+            InputControlChannelStub* localControlChannel[MAX_IME];
+            sptr<IInputControlChannel> inputControlChannel[MAX_IME];
+            sptr<IInputMethodCore> imsCore[MAX_IME]; // the remote handlers of input method service
+            sptr<IRemoteObject> inputMethodToken[MAX_IME]; // the window token of keyboard
+            int currentKbdIndex[MAX_IME]; // current keyboard index
+            int lastImeIndex; // The last ime which showed keyboard
+            InputMethodSetting* inputMethodSetting; // The pointer referred to the object in PerUserSetting
+            int currentDisplayMode; // the display mode of the current keyboard
 
             sptr<IInputMethodAgent> imsAgent;
-            InputChannel* imsChannel; //!< the write channel created by input method service
-            sptr<IInputClient> currentClient; //!< the current input client
-            sptr<IInputClient> needReshowClient; //!< the input client for which keyboard need to re-show
+            InputChannel* imsChannel; // the write channel created by input method service
+            sptr<IInputClient> currentClient; // the current input client
+            sptr<IInputClient> needReshowClient; // the input client for which keyboard need to re-show
 
-            sptr<RemoteObjectDeathRecipient> clientDeathRecipient; //!< remote object death monitor for input client
-            sptr<RemoteObjectDeathRecipient> imsDeathRecipient; //!< remote object death monitor for input method service
-            MessageHandler* msgHandler = nullptr; //!< message handler working with Work Thread
-            std::thread workThreadHandler; //!< work thread handler
-            std::mutex mtx; //!< mutex to lock the operations among multi work threads
+            sptr<RemoteObjectDeathRecipient> clientDeathRecipient; // remote object death monitor for input client
+            sptr<RemoteObjectDeathRecipient> imsDeathRecipient;
+            MessageHandler* msgHandler = nullptr; // message handler working with Work Thread
+            std::thread workThreadHandler; // work thread handler
+            std::mutex mtx; // mutex to lock the operations among multi work threads
             sptr<AAFwk::AbilityConnectionProxy> connCallback;
             sptr<InputMethodAbility> inputMethodAbility_;
 

services/include/peruser_setting.h

@@ -25,49 +25,49 @@
 
 namespace OHOS {
 namespace MiscServices {
-class PerUserSetting {
-public:
-    explicit PerUserSetting(int32_t userId);
+    class PerUserSetting {
+    public:
+        explicit PerUserSetting(int32_t userId);
 
-    ~PerUserSetting();
+        ~PerUserSetting();
 
-    void Initialize();
-    int32_t GetUserState();
-    InputMethodProperty* GetCurrentInputMethod();
-    InputMethodProperty* GetSecurityInputMethod();
-    InputMethodProperty* GetNextInputMethod();
-    InputMethodSetting* GetInputMethodSetting();
-    InputMethodProperty* GetInputMethodProperty(const std::u16string& imeId);
+        void Initialize();
+        int32_t GetUserState();
+        InputMethodProperty* GetCurrentInputMethod();
+        InputMethodProperty* GetSecurityInputMethod();
+        InputMethodProperty* GetNextInputMethod();
+        InputMethodSetting* GetInputMethodSetting();
+        InputMethodProperty* GetInputMethodProperty(const std::u16string& imeId);
 
-    int32_t OnPackageAdded(std::u16string& packageName, bool* isSecurityIme = nullptr);
-    int32_t OnPackageRemoved(std::u16string& packageName, bool* isSecurityIme = nullptr);
-    int32_t OnSettingChanged(const std::u16string& key, const std::u16string& value);
-    void OnAdvanceToNext();
-    void OnUserLocked();
-    void Dump(int32_t fd);
+        int32_t OnPackageAdded(std::u16string& packageName, bool* isSecurityIme = nullptr);
+        int32_t OnPackageRemoved(std::u16string& packageName, bool* isSecurityIme = nullptr);
+        int32_t OnSettingChanged(const std::u16string& key, const std::u16string& value);
+        void OnAdvanceToNext();
+        void OnUserLocked();
+        void Dump(int32_t fd);
 
-    int32_t ListInputMethodEnabled(std::vector<InputMethodProperty*> *properties);
-    int32_t ListInputMethod(std::vector<InputMethodProperty*> *properties);
-    int32_t ListKeyboardType(const std::u16string& imeId, std::vector<KeyboardType*> *types);
+        int32_t ListInputMethodEnabled(std::vector<InputMethodProperty*> *properties);
+        int32_t ListInputMethod(std::vector<InputMethodProperty*> *properties);
+        int32_t ListKeyboardType(const std::u16string& imeId, std::vector<KeyboardType*> *types);
 
-    static bool CheckIfSecurityIme(const InputMethodProperty& property);
+        static bool CheckIfSecurityIme(const InputMethodProperty& property);
 
-private:
-    int32_t userId_; //!< the id of the user to whom the object is linking
-    int32_t userState; //!< the state of the user to whom the object is linking
-    std::vector<InputMethodProperty*> inputMethodProperties; //!< a vector to save all IME installed for this user
-    std::u16string currentImeId; //!< the id of the default input method engine.
-    InputMethodSetting inputMethodSetting; //!< the object to manage the setting data for this user
+    private:
+        int32_t userId_; // the id of the user to whom the object is linking
+        int32_t userState; // the state of the user to whom the object is linking
+        std::vector<InputMethodProperty*> inputMethodProperties; // a vector to save all IME installed for this user
+        std::u16string currentImeId; // the id of the default input method engine.
+        InputMethodSetting inputMethodSetting; // the object to manage the setting data for this user
 
-    PerUserSetting(const PerUserSetting&);
-    PerUserSetting& operator= (const PerUserSetting&);
-    PerUserSetting(const PerUserSetting&&);
-    PerUserSetting& operator= (const PerUserSetting&&);
-    void InitInputMethodSetting();
-    void ResetCurrentInputMethod();
-    std::u16string GetKeyboardTypeLanguage(const InputMethodProperty* property, int32_t hashCode);
-    std::u16string GetImeId(const std::u16string& packageName);
-};
+        PerUserSetting(const PerUserSetting&);
+        PerUserSetting& operator= (const PerUserSetting&);
+        PerUserSetting(const PerUserSetting&&);
+        PerUserSetting& operator= (const PerUserSetting&&);
+        void InitInputMethodSetting();
+        void ResetCurrentInputMethod();
+        std::u16string GetKeyboardTypeLanguage(const InputMethodProperty* property, int32_t hashCode);
+        std::u16string GetImeId(const std::u16string& packageName);
+    };
 }
 }
 #endif // FM_IMMS_PROJECT_PERUSERSETTING_H

services/include/platform.h

@@ -28,18 +28,18 @@
 
 namespace OHOS {
     namespace MiscServices {
-
-
         class Platform {
         public:
             static Platform* Instance();
             void SetPlatform(const sptr<IPlatformApi>& platformApi);
-            sptr<IInputMethodCore> BindInputMethodService(int userId, const std::u16string& packageName, const std::u16string& intention);
+            sptr<IInputMethodCore> BindInputMethodService(int userId, const std::u16string& packageName,
+                                                          const std::u16string& intention);
             int UnbindInputMethodService(int userId, const std::u16string& packageName);
             sptr<IRemoteObject> CreateWindowToken(int userId, int displayId, const std::u16string& packageName);
             int DestroyWindowToken(int userId, const std::u16string& packageName);
-            int ListInputMethod(int userId, std::vector<InputMethodProperty*>* inputMethodProperties);
-            int GetInputMethodProperty(int userId, const std::u16string& packageName, InputMethodProperty* inputMethodProperty);
+            int ListInputMethod(int userId, std::vector<InputMethodProperty*>* properties);
+            int GetInputMethodProperty(int userId, const std::u16string& packageName,
+                                       InputMethodProperty* inputMethodProperty);
             int GetInputMethodSetting(int userId, InputMethodSetting* inputMethodSetting);
             int SetInputMethodSetting(int userId, const InputMethodSetting& inputMethodSetting);
             bool CheckPhysicalKeyboard();

services/include/platform_callback_stub.h

@@ -24,13 +24,13 @@
 
 namespace OHOS {
     namespace MiscServices {
-
         class PlatformCallbackStub : public IRemoteStub<IPlatformCallback> {
         public:
             PlatformCallbackStub();
             ~PlatformCallbackStub();
 
-            virtual int  OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) override;
+            virtual int  OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply,
+                                         MessageOption &option) override;
             virtual void notifyEvent(int eventId, int userId, const std::vector<std::u16string>& eventContent) override;
         };
 

services/include/utils.h

@@ -25,15 +25,15 @@
 
 namespace OHOS {
 namespace MiscServices {
-class Utils {
-    public:
-        static std::string to_utf8( std::u16string str16 ) {
-            return std::wstring_convert< std::codecvt_utf8_utf16<char16_t>, char16_t >{}.to_bytes(str16);
-        }
-        static std::u16string to_utf16( std::string str ) {
-            return std::wstring_convert< std::codecvt_utf8_utf16<char16_t>, char16_t >{}.from_bytes(str);
-        }
-};
+    class Utils {
+        public:
+            static std::string to_utf8(std::u16string str16) {
+                return std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t>{}.to_bytes(str16);
+            }
+            static std::u16string to_utf16(std::string str) {
+                return std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t>{}.from_bytes(str);
+            }
+    };
 }
 }
 

services/src/global.cpp

@@ -18,206 +18,204 @@
 
 namespace OHOS {
 namespace MiscServices {
-
-void LogTimeStamp()
-{
-    struct timeval tv;
-    gettimeofday(&tv, nullptr);
-    struct tm nowTime;
-    localtime_r(&tv.tv_sec, &nowTime);
-    printf("%02d-%02d %02d:%02d:%02d.%03d\t", nowTime.tm_mon, nowTime.tm_mday,
-        nowTime.tm_hour, nowTime.tm_min, nowTime.tm_sec, (int)tv.tv_usec/1000);
-}
-
-namespace ErrorCode {
-    const char* ToString(int errorCode)
+    void LogTimeStamp()
     {
-        switch (errorCode) {
-            case NO_ERROR: {
-                return "no error";
-            }
-            case ERROR_NULL_POINTER: {
-                return "null pointer";
-            }
-            case ERROR_BAD_PARAMETERS: {
-                return "bad parameters";
-            }
-            case ERROR_SERVICE_START_FAILED: {
-                return "failed to start service";
-            }
-            case ERROR_USER_NOT_STARTED: {
-                return "user has not started";
-            }
-            case ERROR_USER_ALREADY_STARTED: {
-                return "user has already started";
-            }
-            case ERROR_USER_NOT_UNLOCKED: {
-                return "user has not unlocked";
-            }
-            case ERROR_USER_ALREADY_UNLOCKED: {
-                return "user has already unlocked";
-            }
-            case ERROR_USER_NOT_LOCKED: {
-                return "user has not locked";
-            }
-            case ERROR_IME_NOT_AVAILABLE: {
-                return "input method engine is not available";
-            }
-            case ERROR_SECURITY_IME_NOT_AVAILABLE: {
-                return "security input method engine is not available";
-            }
-            case ERROR_TOKEN_CREATE_FAILED: {
-                return "failed to create token";
-            }
-            case ERROR_TOKEN_DESTROY_FAILED: {
-                return "failed to destroy token";
-            }
-            case ERROR_IME_BIND_FAILED: {
-                return "failed to bind service";
-            }
-            case ERROR_IME_UNBIND_FAILED: {
-                return "failed to unbind service";
-            }
-            case ERROR_IME_START_FAILED: {
-                return "failed to start input";
-            }
-            case ERROR_IME_STOP_FAILED: {
-                return "failed to stop input";
-            }
-            case ERROR_KBD_SHOW_FAILED: {
-                return "failed to show keyboard";
-            }
-            case ERROR_KBD_HIDE_FAILED: {
-                return "failed to hide keyboard";
-            }
-            case ERROR_IME_NOT_STARTED: {
-                return "input method service has not started";
-            }
-            case ERROR_KBD_IS_OCCUPIED: {
-                return "keyboard is showing by another client";
-            }
-            case ERROR_KBD_IS_NOT_SHOWING: {
-                return "keyboard is not showing";
-            }
-            case ERROR_IME_ALREADY_STARTED: {
-                return "input method service has already started";
-            }
-            case ERROR_NOT_IME_PACKAGE: {
-                return "not an input method engine package";
-            }
-            case ERROR_IME_PACKAGE_DUPLICATED: {
-                return "duplicated input method engine package";
-            }
-            case ERROR_SETTING_SAME_VALUE: {
-                return "same setting value";
-            }
-            case ERROR_NO_NEXT_IME: {
-                return "next input method engine is not available";
-            }
-            case ERROR_CLIENTWINDOW_NOT_FOCUSED: {
-                return "input client window is not focused";
-            }
-            case ERROR_CLIENT_NOT_WINDOW: {
-                return "input client is not from a valid window";
-            }
-            case ERROR_REMOTE_IME_DIED: {
-                return "input method service died";
-            }
-            case ERROR_RESTART_IME_FAILED: {
-                return "failed to restart input method service";
-            }
-            case ERROR_REMOTE_CLIENT_DIED: {
-                return "input client died";
-            }
-            case ERROR_CLIENT_DUPLICATED: {
-                return "duplicated client";
-            }
-            case ERROR_CLIENT_NOT_FOUND: {
-                return "client is not found";
-            }
-            case ERROR_STATUS_UNKNOWN_ERROR: {
-                return "unknown error";
-            }
-            case ERROR_STATUS_NO_MEMORY: {
-                return "no memory";
-            }
-            case ERROR_STATUS_INVALID_OPERATION: {
-                return "invalid operation";
-            }
-            case ERROR_STATUS_BAD_VALUE: {
-                return "bad value";
-            }
-            case ERROR_STATUS_BAD_TYPE: {
-                return "bad type";
-            }
-            case ERROR_STATUS_NAME_NOT_FOUND: {
-                return "name not found";
-            }
-            case ERROR_STATUS_PERMISSION_DENIED: {
-                return "permission denied";
-            }
-            case ERROR_STATUS_NO_INIT: {
-                return "no init";
-            }
-            case ERROR_STATUS_ALREADY_EXISTS: {
-                return "already exists";
-            }
-            case ERROR_STATUS_DEAD_OBJECT: {
-                return "dead object";
-            }
-            case ERROR_STATUS_FAILED_TRANSACTION: {
-                return "failed transaction";
-            }
-            case ERROR_STATUS_BAD_INDEX: {
-                return "bad index";
-            }
-            case ERROR_STATUS_NOT_ENOUGH_DATA: {
-                return "not enough data";
-            }
-            case ERROR_STATUS_WOULD_BLOCK: {
-                return "would block";
-            }
-            case ERROR_STATUS_TIMED_OUT: {
-                return "time out";
-            }
-            case ERROR_STATUS_UNKNOWN_TRANSACTION: {
-                return "unknown transaction";
-            }
-            case ERROR_STATUS_FDS_NOT_ALLOWED: {
-                return "fds not allowed";
-            }
-            case ERROR_STATUS_UNEXPECTED_NULL: {
-                return "unexpected null";
-            }
-            case ERROR_EX_ILLEGAL_ARGUMENT: {
-                return "illegal argument exception";
-            }
-            case ERROR_EX_NULL_POINTER: {
-                return "null pointer exception";
-            }
-            case ERROR_EX_ILLEGAL_STATE: {
-                return "illegal state exception";
-            }
-            case ERROR_EX_NETWORK_MAIN_THREAD: {
-                return "network main thread exception";
-            }
-            case ERROR_EX_UNSUPPORTED_OPERATION: {
-                return "unsupported operation exception";
-            }
-            case ERROR_EX_SERVICE_SPECIFIC: {
-                return "service specific exception";
-            }
-            case ERROR_EX_PARCELABLE: {
-                return "parcelable exception";
-            }
-            default: {
-                return "error is out of definition";
-            }
-        }
-        return "error is out of definition";
-    };
-}
+        struct timeval tv;
+        gettimeofday(&tv, nullptr);
+        struct tm nowTime;
+        localtime_r(&tv.tv_sec, &nowTime);
+        printf("%02d-%02d %02d:%02d:%02d.%03d\t", nowTime.tm_mon, nowTime.tm_mday,
+            nowTime.tm_hour, nowTime.tm_min, nowTime.tm_sec, (int)tv.tv_usec/1000);
+    }
 
+    namespace ErrorCode {
+        const char* ToString(int errorCode)
+        {
+            switch (errorCode) {
+                case NO_ERROR: {
+                    return "no error";
+                }
+                case ERROR_NULL_POINTER: {
+                    return "null pointer";
+                }
+                case ERROR_BAD_PARAMETERS: {
+                    return "bad parameters";
+                }
+                case ERROR_SERVICE_START_FAILED: {
+                    return "failed to start service";
+                }
+                case ERROR_USER_NOT_STARTED: {
+                    return "user has not started";
+                }
+                case ERROR_USER_ALREADY_STARTED: {
+                    return "user has already started";
+                }
+                case ERROR_USER_NOT_UNLOCKED: {
+                    return "user has not unlocked";
+                }
+                case ERROR_USER_ALREADY_UNLOCKED: {
+                    return "user has already unlocked";
+                }
+                case ERROR_USER_NOT_LOCKED: {
+                    return "user has not locked";
+                }
+                case ERROR_IME_NOT_AVAILABLE: {
+                    return "input method engine is not available";
+                }
+                case ERROR_SECURITY_IME_NOT_AVAILABLE: {
+                    return "security input method engine is not available";
+                }
+                case ERROR_TOKEN_CREATE_FAILED: {
+                    return "failed to create token";
+                }
+                case ERROR_TOKEN_DESTROY_FAILED: {
+                    return "failed to destroy token";
+                }
+                case ERROR_IME_BIND_FAILED: {
+                    return "failed to bind service";
+                }
+                case ERROR_IME_UNBIND_FAILED: {
+                    return "failed to unbind service";
+                }
+                case ERROR_IME_START_FAILED: {
+                    return "failed to start input";
+                }
+                case ERROR_IME_STOP_FAILED: {
+                    return "failed to stop input";
+                }
+                case ERROR_KBD_SHOW_FAILED: {
+                    return "failed to show keyboard";
+                }
+                case ERROR_KBD_HIDE_FAILED: {
+                    return "failed to hide keyboard";
+                }
+                case ERROR_IME_NOT_STARTED: {
+                    return "input method service has not started";
+                }
+                case ERROR_KBD_IS_OCCUPIED: {
+                    return "keyboard is showing by another client";
+                }
+                case ERROR_KBD_IS_NOT_SHOWING: {
+                    return "keyboard is not showing";
+                }
+                case ERROR_IME_ALREADY_STARTED: {
+                    return "input method service has already started";
+                }
+                case ERROR_NOT_IME_PACKAGE: {
+                    return "not an input method engine package";
+                }
+                case ERROR_IME_PACKAGE_DUPLICATED: {
+                    return "duplicated input method engine package";
+                }
+                case ERROR_SETTING_SAME_VALUE: {
+                    return "same setting value";
+                }
+                case ERROR_NO_NEXT_IME: {
+                    return "next input method engine is not available";
+                }
+                case ERROR_CLIENTWINDOW_NOT_FOCUSED: {
+                    return "input client window is not focused";
+                }
+                case ERROR_CLIENT_NOT_WINDOW: {
+                    return "input client is not from a valid window";
+                }
+                case ERROR_REMOTE_IME_DIED: {
+                    return "input method service died";
+                }
+                case ERROR_RESTART_IME_FAILED: {
+                    return "failed to restart input method service";
+                }
+                case ERROR_REMOTE_CLIENT_DIED: {
+                    return "input client died";
+                }
+                case ERROR_CLIENT_DUPLICATED: {
+                    return "duplicated client";
+                }
+                case ERROR_CLIENT_NOT_FOUND: {
+                    return "client is not found";
+                }
+                case ERROR_STATUS_UNKNOWN_ERROR: {
+                    return "unknown error";
+                }
+                case ERROR_STATUS_NO_MEMORY: {
+                    return "no memory";
+                }
+                case ERROR_STATUS_INVALID_OPERATION: {
+                    return "invalid operation";
+                }
+                case ERROR_STATUS_BAD_VALUE: {
+                    return "bad value";
+                }
+                case ERROR_STATUS_BAD_TYPE: {
+                    return "bad type";
+                }
+                case ERROR_STATUS_NAME_NOT_FOUND: {
+                    return "name not found";
+                }
+                case ERROR_STATUS_PERMISSION_DENIED: {
+                    return "permission denied";
+                }
+                case ERROR_STATUS_NO_INIT: {
+                    return "no init";
+                }
+                case ERROR_STATUS_ALREADY_EXISTS: {
+                    return "already exists";
+                }
+                case ERROR_STATUS_DEAD_OBJECT: {
+                    return "dead object";
+                }
+                case ERROR_STATUS_FAILED_TRANSACTION: {
+                    return "failed transaction";
+                }
+                case ERROR_STATUS_BAD_INDEX: {
+                    return "bad index";
+                }
+                case ERROR_STATUS_NOT_ENOUGH_DATA: {
+                    return "not enough data";
+                }
+                case ERROR_STATUS_WOULD_BLOCK: {
+                    return "would block";
+                }
+                case ERROR_STATUS_TIMED_OUT: {
+                    return "time out";
+                }
+                case ERROR_STATUS_UNKNOWN_TRANSACTION: {
+                    return "unknown transaction";
+                }
+                case ERROR_STATUS_FDS_NOT_ALLOWED: {
+                    return "fds not allowed";
+                }
+                case ERROR_STATUS_UNEXPECTED_NULL: {
+                    return "unexpected null";
+                }
+                case ERROR_EX_ILLEGAL_ARGUMENT: {
+                    return "illegal argument exception";
+                }
+                case ERROR_EX_NULL_POINTER: {
+                    return "null pointer exception";
+                }
+                case ERROR_EX_ILLEGAL_STATE: {
+                    return "illegal state exception";
+                }
+                case ERROR_EX_NETWORK_MAIN_THREAD: {
+                    return "network main thread exception";
+                }
+                case ERROR_EX_UNSUPPORTED_OPERATION: {
+                    return "unsupported operation exception";
+                }
+                case ERROR_EX_SERVICE_SPECIFIC: {
+                    return "service specific exception";
+                }
+                case ERROR_EX_PARCELABLE: {
+                    return "parcelable exception";
+                }
+                default: {
+                    return "error is out of definition";
+                }
+            }
+            return "error is out of definition";
+        };
+    }
 }
 }
 

services/src/input_attribute.cpp

@@ -17,89 +17,89 @@
 
 namespace OHOS {
 namespace MiscServices {
-/*! Constructor
-*/
-InputAttribute::InputAttribute() : enterKeyType(0), inputOption(0)
-{
-}
+    /*! Constructor
+    */
+    InputAttribute::InputAttribute() : enterKeyType(0), inputOption(0)
+    {
+    }
 
-/*! Constructor
-  \param attribute the source attribute copied to this instance
-*/
-InputAttribute::InputAttribute(const InputAttribute& attribute)
-{
-    inputPattern = attribute.inputPattern;
-    enterKeyType = attribute.enterKeyType;
-    inputOption = attribute.inputOption;
-}
+    /*! Constructor
+      \param attribute the source attribute copied to this instance
+    */
+    InputAttribute::InputAttribute(const InputAttribute& attribute)
+    {
+        inputPattern = attribute.inputPattern;
+        enterKeyType = attribute.enterKeyType;
+        inputOption = attribute.inputOption;
+    }
 
-/*! Destructor
-*/
-InputAttribute::~InputAttribute()
-{
-}
+    /*! Destructor
+    */
+    InputAttribute::~InputAttribute()
+    {
+    }
 
-/*! operator=
-  \param attribute the source attribute copied to this instance
-  \return return this
-*/
-InputAttribute& InputAttribute::operator=(const InputAttribute& attribute)
-{
-    if (this == &attribute) {
+    /*! operator=
+      \param attribute the source attribute copied to this instance
+      \return return this
+    */
+    InputAttribute& InputAttribute::operator=(const InputAttribute& attribute)
+    {
+        if (this == &attribute) {
+            return *this;
+        }
+        inputPattern = attribute.inputPattern;
+        enterKeyType = attribute.enterKeyType;
+        inputOption = attribute.inputOption;
         return *this;
     }
-    inputPattern = attribute.inputPattern;
-    enterKeyType = attribute.enterKeyType;
-    inputOption = attribute.inputOption;
-    return *this;
-}
 
-/*! Write InputAttribute to parcel
-  \param[out] parcel write the data of InputAttribute to this parcel returned to caller
-  \return ErrorCode::NO_ERROR
-  \return ErrorCode::ERROR_NULL_POINTER parcel is null
-*/
-bool InputAttribute::Marshalling(OHOS::Parcel &parcel) const {
-    if (!(parcel.WriteInt32(inputPattern)
-              && parcel.WriteInt32(enterKeyType)
-              && parcel.WriteInt32(inputOption)))
-        return false;
-    return true;
-}
-
-/*! Read InputAttribute from parcel
-  \param parcel read the data of InputAttribute from this parcel
-  \return ErrorCode::NO_ERROR
-  \return ErrorCode::ERROR_NULL_POINTER parcel is null
-*/
-InputAttribute* InputAttribute::Unmarshalling(OHOS::Parcel &parcel) {
-    auto info = new InputAttribute();
-    info->inputPattern = parcel.ReadInt32();
-    info->enterKeyType = parcel.ReadInt32();
-    info->inputOption = parcel.ReadInt32();
-    return info;
-}
-
-/*! Get the security flag
-  \return true - It's password EditView. The input method management service should start system
-  security input method engine for this view.
-  \return false - It's an normal view.
-*/
-bool InputAttribute::GetSecurityFlag()
-{
-    if (inputPattern == PATTERN_PASSWORD) {
+    /*! Write InputAttribute to parcel
+      \param[out] parcel write the data of InputAttribute to this parcel returned to caller
+      \return ErrorCode::NO_ERROR
+      \return ErrorCode::ERROR_NULL_POINTER parcel is null
+    */
+    bool InputAttribute::Marshalling(OHOS::Parcel &parcel) const {
+        if (!(parcel.WriteInt32(inputPattern)
+                  && parcel.WriteInt32(enterKeyType)
+                  && parcel.WriteInt32(inputOption)))
+            return false;
         return true;
     }
-    return false;
-}
 
-/*! Set input pattern.
-    \n It's added for Unit test of PerUserSession
-    \param pattern PATTERN_PASSWORD or 0.
-*/
-void InputAttribute::SetInputPattern(int32_t pattern)
-{
-    inputPattern = pattern;
-}
+    /*! Read InputAttribute from parcel
+      \param parcel read the data of InputAttribute from this parcel
+      \return ErrorCode::NO_ERROR
+      \return ErrorCode::ERROR_NULL_POINTER parcel is null
+    */
+    InputAttribute* InputAttribute::Unmarshalling(OHOS::Parcel &parcel) {
+        auto info = new InputAttribute();
+        info->inputPattern = parcel.ReadInt32();
+        info->enterKeyType = parcel.ReadInt32();
+        info->inputOption = parcel.ReadInt32();
+        return info;
+    }
+
+    /*! Get the security flag
+      \return true - It's password EditView. The input method management service should start system
+      security input method engine for this view.
+      \return false - It's an normal view.
+    */
+    bool InputAttribute::GetSecurityFlag()
+    {
+        if (inputPattern == PATTERN_PASSWORD) {
+            return true;
+        }
+        return false;
+    }
+
+    /*! Set input pattern.
+        \n It's added for Unit test of PerUserSession
+        \param pattern PATTERN_PASSWORD or 0.
+    */
+    void InputAttribute::SetInputPattern(int32_t pattern)
+    {
+        inputPattern = pattern;
+    }
 }
 }

services/src/input_channel.cpp

@@ -19,42 +19,42 @@
 
 namespace OHOS {
 namespace MiscServices {
-/*! Constructor
-*/
-InputChannel::InputChannel()
-{
-}
+    /*! Constructor
+    */
+    InputChannel::InputChannel()
+    {
+    }
 
-/*! Destructor
-*/
-InputChannel::~InputChannel()
-{
-}
+    /*! Destructor
+    */
+    InputChannel::~InputChannel()
+    {
+    }
 
-/*! Write InputChannel to parcel
-  \param[out] parcel the data of InputChannel is written to this parcel returned to caller
-  \return ErrorCode::NO_ERROR
-  \return ErrorCode::ERROR_NULL_POINTER parcel is null
-*/
-bool InputChannel::Marshalling(Parcel &parcel) const {
-    parcel.ParseFrom(inputChannelParcel.GetData(), inputChannelParcel.GetDataSize());
-    return NO_ERROR;
-}
+    /*! Write InputChannel to parcel
+      \param[out] parcel the data of InputChannel is written to this parcel returned to caller
+      \return ErrorCode::NO_ERROR
+      \return ErrorCode::ERROR_NULL_POINTER parcel is null
+    */
+    bool InputChannel::Marshalling(Parcel &parcel) const {
+        parcel.ParseFrom(inputChannelParcel.GetData(), inputChannelParcel.GetDataSize());
+        return NO_ERROR;
+    }
 
-/*! Get InputChannel from parcel
-  \param parcel get the data of InputChannel from this parcel
-  \return ErrorCode::NO_ERROR
-  \return ErrorCode::ERROR_NULL_POINTER parcel is null
-*/
-InputChannel* InputChannel::Unmarshalling(Parcel &parcel) {
-    auto inputChannel = new InputChannel();
-    inputChannel->inputChannelParcel.RewindRead(0);
-    inputChannel->inputChannelParcel.ParseFrom(parcel.GetData(), parcel.GetDataSize());
-    inputChannel->inputChannelParcel.RewindRead(0);
+    /*! Get InputChannel from parcel
+      \param parcel get the data of InputChannel from this parcel
+      \return ErrorCode::NO_ERROR
+      \return ErrorCode::ERROR_NULL_POINTER parcel is null
+    */
+    InputChannel* InputChannel::Unmarshalling(Parcel &parcel) {
+        auto inputChannel = new InputChannel();
+        inputChannel->inputChannelParcel.RewindRead(0);
+        inputChannel->inputChannelParcel.ParseFrom(parcel.GetData(), parcel.GetDataSize());
+        inputChannel->inputChannelParcel.RewindRead(0);
 
-    inputChannel->name = inputChannel->inputChannelParcel.ReadString16();
-    inputChannel->inputChannelParcel.RewindRead(0);
-    return inputChannel;
-}
+        inputChannel->name = inputChannel->inputChannelParcel.ReadString16();
+        inputChannel->inputChannelParcel.RewindRead(0);
+        return inputChannel;
+    }
 }
 }

services/src/input_control_channel_proxy.cpp

@@ -24,7 +24,6 @@
 #include "i_input_method_agent.h"
 #include "input_control_channel_proxy.h"
 
-
 /*! \class InputControlChannelProxy
   \brief The proxy implementation of IInputControlChannel
 
@@ -32,7 +31,8 @@
 */
 namespace OHOS {
 namespace MiscServices {
-    InputControlChannelProxy::InputControlChannelProxy(const sptr<IRemoteObject> &impl) : IRemoteProxy<IInputControlChannel>(impl) {
+    InputControlChannelProxy::InputControlChannelProxy(const sptr<IRemoteObject> &impl)
+        : IRemoteProxy<IInputControlChannel>(impl) {
     }
 
     InputControlChannelProxy::~InputControlChannelProxy()

services/src/input_control_channel_stub.cpp

@@ -45,7 +45,8 @@ namespace OHOS {
         \param flags the flags of handling transaction
         \return int32_t
         */
-        int32_t InputControlChannelStub::OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option)
+        int32_t InputControlChannelStub::OnRemoteRequest(uint32_t code, MessageParcel& data,
+                                                         MessageParcel& reply, MessageOption& option)
         {
             IMSA_HILOGI("InputControlChannelStub::OnRemoteRequest code = %{public}u", code);
             auto descriptorToken = data.ReadInterfaceToken();

services/src/input_method_ability_connection_stub.cpp

@@ -17,7 +17,6 @@
 #include "message_parcel.h"
 #include "message.h"
 
-
 namespace OHOS {
     namespace MiscServices {
         InputMethodAbilityConnectionStub::InputMethodAbilityConnectionStub(const int index){
@@ -28,7 +27,8 @@ namespace OHOS {
 
         }
 
-        void InputMethodAbilityConnectionStub::OnAbilityConnectDone(const AppExecFwk::ElementName &element, const sptr<IRemoteObject> &remoteObject, int resultCode){
+        void InputMethodAbilityConnectionStub::OnAbilityConnectDone(const AppExecFwk::ElementName &element,
+                                               const sptr<IRemoteObject> &remoteObject, int resultCode){
             IMSA_HILOGE("ConnectAbility: OnAbilityConnectDone.");
             if(messageHandler != nullptr){
                 MessageParcel* data = new MessageParcel();
@@ -40,7 +40,8 @@ namespace OHOS {
             }
         }
 
-        void InputMethodAbilityConnectionStub::OnAbilityDisconnectDone(const AppExecFwk::ElementName &element, int resultCode) {
+        void InputMethodAbilityConnectionStub::OnAbilityDisconnectDone(const AppExecFwk::ElementName &element,
+                                                                       int resultCode) {
             IMSA_HILOGE("ConnectAbility: OnAbilityDisconnectDone.");
             if(messageHandler != nullptr){
                 MessageParcel* data = new MessageParcel();

services/src/input_method_agent_proxy.cpp

@@ -42,9 +42,7 @@ namespace OHOS {
                 (void)status;
                 return NO_ERROR;
             }
-
         };
-
     }
 }
 

services/src/input_method_property.cpp

@@ -17,114 +17,110 @@
 
 namespace OHOS {
 namespace MiscServices {
-using namespace std;
-/*! Constructor
-*/
-InputMethodProperty::InputMethodProperty()
-{
-}
-
-/*! Destructor
-*/
-InputMethodProperty::~InputMethodProperty()
-{
-    for(int32_t i=0; i<(int32_t)mTypes.size(); i++) {
-        delete mTypes[i];
+    using namespace std;
+    /*! Constructor
+    */
+    InputMethodProperty::InputMethodProperty()
+    {
     }
-    mTypes.clear();
-}
 
-/*! Constructor
-\param property the source property will be copied to this instance.
-*/
-InputMethodProperty::InputMethodProperty(const InputMethodProperty& property)
-{
-    mImeId = property.mImeId;
-    mPackageName = property.mPackageName;
-    mAbilityName = property.mAbilityName;
-    mConfigurationPage = property.mConfigurationPage;
-    isSystemIme = property.isSystemIme;
-    mDefaultImeId = property.mDefaultImeId;
-
-    for(int i = 0; i < (int)mTypes.size(); i++) {
-        KeyboardType* type = new KeyboardType(*property.mTypes[i]);
-        mTypes.push_back(type);
+    /*! Destructor
+    */
+    InputMethodProperty::~InputMethodProperty()
+    {
+        for(int32_t i=0; i<(int32_t)mTypes.size(); i++) {
+            delete mTypes[i];
+        }
+        mTypes.clear();
     }
-}
 
-/*! operator=
-\param property the source property will be copied to this instance.
-\return return this
-*/
-InputMethodProperty& InputMethodProperty::operator=(const InputMethodProperty& property)
-{
-    if (this == &property) {
+    /*! Constructor
+    \param property the source property will be copied to this instance.
+    */
+    InputMethodProperty::InputMethodProperty(const InputMethodProperty& property)
+    {
+        mImeId = property.mImeId;
+        mPackageName = property.mPackageName;
+        mAbilityName = property.mAbilityName;
+        mConfigurationPage = property.mConfigurationPage;
+        isSystemIme = property.isSystemIme;
+        mDefaultImeId = property.mDefaultImeId;
+
+        for(int i = 0; i < (int)mTypes.size(); i++) {
+            KeyboardType* type = new KeyboardType(*property.mTypes[i]);
+            mTypes.push_back(type);
+        }
+    }
+
+    /*! operator=
+    \param property the source property will be copied to this instance.
+    \return return this
+    */
+    InputMethodProperty& InputMethodProperty::operator=(const InputMethodProperty& property)
+    {
+        if (this == &property) {
+            return *this;
+        }
+        mImeId = property.mImeId;
+        mPackageName = property.mPackageName;
+        mAbilityName = property.mAbilityName;
+        mConfigurationPage = property.mConfigurationPage;
+        isSystemIme = property.isSystemIme;
+        mDefaultImeId = property.mDefaultImeId;
+
+        for(int i = 0; i < (int)mTypes.size(); i++) {
+            KeyboardType* type = new KeyboardType(*property.mTypes[i]);
+            mTypes.push_back(type);
+        }
         return *this;
     }
-    mImeId = property.mImeId;
-    mPackageName = property.mPackageName;
-    mAbilityName = property.mAbilityName;
-    mConfigurationPage = property.mConfigurationPage;
-    isSystemIme = property.isSystemIme;
-    mDefaultImeId = property.mDefaultImeId;
 
-    for(int i = 0; i < (int)mTypes.size(); i++) {
-        KeyboardType* type = new KeyboardType(*property.mTypes[i]);
-        mTypes.push_back(type);
-    }
-    return *this;
-}
-
-/*! Write InputMethodProperty to parcel
-\param[out] parcel the information is written to this parcel returned to caller
-\return ErrorCode::NO_ERROR
-\return ErrorCode::ERROR_NULL_POINTER parcel is null
-*/
-bool InputMethodProperty::Marshalling(Parcel &parcel) const
-{
-    if (!(parcel.WriteString16(mImeId)
-            &&parcel.WriteString16(mPackageName)
-            &&parcel.WriteString16(mAbilityName)
-            &&parcel.WriteString16(mConfigurationPage)
-            &&parcel.WriteBool(isSystemIme)
-            &&parcel.WriteInt32(mDefaultImeId))) 
-        return false;
-    int32_t size = (int32_t)mTypes.size();
-    parcel.WriteInt32(size);
-    if (size == 0) 
+    /*! Write InputMethodProperty to parcel
+    \param[out] parcel the information is written to this parcel returned to caller
+    \return ErrorCode::NO_ERROR
+    \return ErrorCode::ERROR_NULL_POINTER parcel is null
+    */
+    bool InputMethodProperty::Marshalling(Parcel &parcel) const
+    {
+        if (!(parcel.WriteString16(mImeId)
+                &&parcel.WriteString16(mPackageName)
+                &&parcel.WriteString16(mAbilityName)
+                &&parcel.WriteString16(mConfigurationPage)
+                &&parcel.WriteBool(isSystemIme)
+                &&parcel.WriteInt32(mDefaultImeId)))
+            return false;
+        int32_t size = (int32_t)mTypes.size();
+        parcel.WriteInt32(size);
+        if (size == 0)
+            return true;
+        for(int i=0; i<size; i++){
+            parcel.WriteParcelable(mTypes[i]);
+        }
         return true;
-    for(int i=0; i<size; i++){
-        parcel.WriteParcelable(mTypes[i]);
     }
-    return true;
-}
 
-/*! Get InputMethodProperty from parcel
-\param parcel read InputMethodProperty from this parcel
-\return ErrorCode::NO_ERROR
-\return ErrorCode::ERROR_NULL_POINTER parcel is null
-*/
-InputMethodProperty* InputMethodProperty::Unmarshalling(Parcel &parcel)
-{
-    auto info = new InputMethodProperty();
-    info->mImeId = parcel.ReadString16();
-    info->mPackageName = parcel.ReadString16();
-    info->mAbilityName = parcel.ReadString16();
-    info->mConfigurationPage = parcel.ReadString16();
-    info->isSystemIme = parcel.ReadBool();
-    info->mDefaultImeId = parcel.ReadInt32();
+    /*! Get InputMethodProperty from parcel
+    \param parcel read InputMethodProperty from this parcel
+    \return ErrorCode::NO_ERROR
+    \return ErrorCode::ERROR_NULL_POINTER parcel is null
+    */
+    InputMethodProperty* InputMethodProperty::Unmarshalling(Parcel &parcel)
+    {
+        auto info = new InputMethodProperty();
+        info->mImeId = parcel.ReadString16();
+        info->mPackageName = parcel.ReadString16();
+        info->mAbilityName = parcel.ReadString16();
+        info->mConfigurationPage = parcel.ReadString16();
+        info->isSystemIme = parcel.ReadBool();
+        info->mDefaultImeId = parcel.ReadInt32();
 
-    int32_t size = parcel.ReadInt32();
-    if (size == 0)
+        int32_t size = parcel.ReadInt32();
+        if (size == 0)
+            return info;
+        for (int i =0; i < size; i++) {
+            info->mTypes.push_back(parcel.ReadParcelable<KeyboardType>());
+        }
         return info;
-    for (int i =0; i < size; i++) {
-        info->mTypes.push_back(parcel.ReadParcelable<KeyboardType>());
     }
-    return info;
 }
-}
-}
-
-
-
-
+}

services/src/input_method_system_ability_stub.cpp

@@ -19,101 +19,118 @@
 
 namespace OHOS {
 namespace MiscServices {
+    using namespace MessageID;
+    /*! Handle the transaction from the remote binder
+    \n Run in binder thread
+    \param code transaction code number
+    \param data the parameters from remote binder
+    \param[out] reply the result of the transaction replied to the remote binder
+    \param flags the flags of handling transaction
+    \return int32_t
+    */
+    int32_t InputMethodSystemAbilityStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply,
+        MessageOption &option)
+    {
+        IMSA_HILOGI("InputMethodSystemAbilityStub::OnRemoteRequest code = %{public}u", code);
+        auto descriptorToken = data.ReadInterfaceToken();
+        if (descriptorToken != GetDescriptor()) {
+            return ErrorCode::ERROR_STATUS_UNKNOWN_TRANSACTION;
+        }
 
-using namespace MessageID;
-/*! Handle the transaction from the remote binder
-\n Run in binder thread
-\param code transaction code number
-\param data the parameters from remote binder
-\param[out] reply the result of the transaction replied to the remote binder
-\param flags the flags of handling transaction
-\return int32_t
-*/
-int32_t InputMethodSystemAbilityStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply,
-    MessageOption &option)
-{
-    IMSA_HILOGI("InputMethodSystemAbilityStub::OnRemoteRequest code = %{public}u", code);
-    auto descriptorToken = data.ReadInterfaceToken();
-    if (descriptorToken != GetDescriptor()) {
-        return ErrorCode::ERROR_STATUS_UNKNOWN_TRANSACTION;
-    }
-
-    switch(code) {
-        case PREPARE_INPUT: {
-            prepareInput(data);
-            reply.WriteInt32(NO_ERROR);
-            break;
-        }
-        case RELEASE_INPUT: {
-            MessageParcel* msgParcel = (MessageParcel*) &data;
-            releaseInput(*msgParcel);
-            reply.WriteInt32(NO_ERROR);
-            break;
-        }
-        case START_INPUT: {
-            MessageParcel* msgParcel = (MessageParcel*) &data;
-            startInput(*msgParcel);
-            reply.WriteInt32(NO_ERROR);
-            break;
-        }
-        case STOP_INPUT: {
-            MessageParcel* msgParcel = (MessageParcel*) &data;
-            stopInput(*msgParcel);
-            reply.WriteInt32(NO_ERROR);
-            break;
-        }
-        case SET_INPUT_METHOD_CORE:{
-            MessageParcel* msgParcel = (MessageParcel*) &data;
-            setInputMethodCoreFromHap(*msgParcel);
-            reply.WriteInt32(NO_ERROR);
-            break;
-        }
-        case GET_DISPLAY_MODE: {
-            int32_t mode = 0;
-            int32_t status = getDisplayMode(&mode);
-            if (status == ErrorCode::NO_ERROR) {
+        switch(code) {
+            case PREPARE_INPUT: {
+                prepareInput(data);
                 reply.WriteInt32(NO_ERROR);
-                reply.WriteInt32(mode);
-            } else {
-                reply.WriteInt32(ErrorCode::ERROR_EX_ILLEGAL_STATE);
-                reply.WriteInt32(-1);
+                break;
             }
-            break;
-        }
-        case GET_KEYBOARD_WINDOW_HEIGHT: {
-            int32_t height = 0;
-            int32_t status = getKeyboardWindowHeight(&height);
-            if (status == ErrorCode::NO_ERROR) {
+            case RELEASE_INPUT: {
+                MessageParcel* msgParcel = (MessageParcel*) &data;
+                releaseInput(*msgParcel);
                 reply.WriteInt32(NO_ERROR);
-                reply.WriteInt32(height);
-            } else {
-                reply.WriteInt32(ErrorCode::ERROR_EX_ILLEGAL_STATE);
-                reply.WriteInt32(-1);
+                break;
             }
-            break;
-        }
-        case GET_CURRENT_KEYBOARD_TYPE: {
-            KeyboardType type;
-            int32_t status = getCurrentKeyboardType(&type);
-            if (status == ErrorCode::NO_ERROR) {
+            case START_INPUT: {
+                MessageParcel* msgParcel = (MessageParcel*) &data;
+                startInput(*msgParcel);
                 reply.WriteInt32(NO_ERROR);
-                reply.WriteParcelable(&type);
-            } else if (status == ErrorCode::ERROR_NULL_POINTER) {
-                reply.WriteInt32(NO_ERROR);
-                reply.WriteInt32(0);
-            } else {
-                reply.WriteInt32(ErrorCode::ERROR_EX_ILLEGAL_STATE);
-                reply.WriteInt32(-1);
+                break;
             }
-            break;
-        }
-        case LIST_INPUT_METHOD_ENABLED: {
-            std::vector<InputMethodProperty*> properties;
-            int32_t ret = listInputMethodEnabled(&properties);
-            if (ret != ErrorCode::NO_ERROR) {
-                reply.WriteInt32(ErrorCode::ERROR_EX_ILLEGAL_STATE); // write exception code
-                reply.WriteInt32(-1);
-            } else {
+            case STOP_INPUT: {
+                MessageParcel* msgParcel = (MessageParcel*) &data;
+                stopInput(*msgParcel);
+                reply.WriteInt32(NO_ERROR);
+                break;
+            }
+            case SET_INPUT_METHOD_CORE:{
+                MessageParcel* msgParcel = (MessageParcel*) &data;
+                setInputMethodCoreFromHap(*msgParcel);
+                reply.WriteInt32(NO_ERROR);
+                break;
+            }
+            case GET_DISPLAY_MODE: {
+                int32_t mode = 0;
+                int32_t status = getDisplayMode(&mode);
+                if (status == ErrorCode::NO_ERROR) {
+                    reply.WriteInt32(NO_ERROR);
+                    reply.WriteInt32(mode);
+                } else {
+                    reply.WriteInt32(ErrorCode::ERROR_EX_ILLEGAL_STATE);
+                    reply.WriteInt32(-1);
+                }
+                break;
+            }
+            case GET_KEYBOARD_WINDOW_HEIGHT: {
+                int32_t height = 0;
+                int32_t status = getKeyboardWindowHeight(&height);
+                if (status == ErrorCode::NO_ERROR) {
+                    reply.WriteInt32(NO_ERROR);
+                    reply.WriteInt32(height);
+                } else {
+                    reply.WriteInt32(ErrorCode::ERROR_EX_ILLEGAL_STATE);
+                    reply.WriteInt32(-1);
+                }
+                break;
+            }
+            case GET_CURRENT_KEYBOARD_TYPE: {
+                KeyboardType type;
+                int32_t status = getCurrentKeyboardType(&type);
+                if (status == ErrorCode::NO_ERROR) {
+                    reply.WriteInt32(NO_ERROR);
+                    reply.WriteParcelable(&type);
+                } else if (status == ErrorCode::ERROR_NULL_POINTER) {
+                    reply.WriteInt32(NO_ERROR);
+                    reply.WriteInt32(0);
+                } else {
+                    reply.WriteInt32(ErrorCode::ERROR_EX_ILLEGAL_STATE);
+                    reply.WriteInt32(-1);
+                }
+                break;
+            }
+            case LIST_INPUT_METHOD_ENABLED: {
+                std::vector<InputMethodProperty*> properties;
+                int32_t ret = listInputMethodEnabled(&properties);
+                if (ret != ErrorCode::NO_ERROR) {
+                    reply.WriteInt32(ErrorCode::ERROR_EX_ILLEGAL_STATE); // write exception code
+                    reply.WriteInt32(-1);
+                } else {
+                    reply.WriteInt32(NO_ERROR);
+                    int32_t size = properties.size();
+                    reply.WriteInt32(size);
+                    for(int32_t i=0; i<size; i++) {
+                        reply.WriteParcelable(properties[i]);
+                    }
+                    properties.clear();
+                }
+                break;
+            }
+            case LIST_INPUT_METHOD: {
+                std::vector<InputMethodProperty*> properties;
+                int32_t ret = listInputMethod(&properties);
+                if (ret != ErrorCode::NO_ERROR) {
+                    reply.WriteInt32(ErrorCode::ERROR_EX_ILLEGAL_STATE); // write exception code
+                    reply.WriteInt32(-1);
+                    return ret;
+                }
                 reply.WriteInt32(NO_ERROR);
                 int32_t size = properties.size();
                 reply.WriteInt32(size);
@@ -121,159 +138,140 @@ int32_t InputMethodSystemAbilityStub::OnRemoteRequest(uint32_t code, MessageParc
                     reply.WriteParcelable(properties[i]);
                 }
                 properties.clear();
+                break;
+            }
+            case LIST_KEYBOARD_TYPE: {
+                std::u16string imeId = data.ReadString16();
+                std::vector<KeyboardType*> kbdTypes;
+                int32_t ret = listKeyboardType(imeId, &kbdTypes);
+                if (ret != ErrorCode::NO_ERROR) {
+                    reply.WriteInt32(ErrorCode::ERROR_EX_ILLEGAL_STATE);
+                    reply.WriteInt32(-1);
+                    return ret;
+                }
+                reply.WriteInt32(NO_ERROR);
+                int32_t size = kbdTypes.size();
+                reply.WriteInt32(size);
+                for(int32_t i=0; i<size; i++) {
+                    reply.WriteParcelable(kbdTypes[i]);
+                }
+                kbdTypes.clear();
+                break;
+            }
+            default: {
+                return BRemoteObject::OnRemoteRequest(code, data, reply, option);
             }
-            break;
-        }
-        case LIST_INPUT_METHOD: {
-            std::vector<InputMethodProperty*> properties;
-            int32_t ret = listInputMethod(&properties);
-            if (ret != ErrorCode::NO_ERROR) {
-                reply.WriteInt32(ErrorCode::ERROR_EX_ILLEGAL_STATE); // write exception code
-                reply.WriteInt32(-1);
-                return ret;
-            }
-            reply.WriteInt32(NO_ERROR);
-            int32_t size = properties.size();
-            reply.WriteInt32(size);
-            for(int32_t i=0; i<size; i++) {
-                reply.WriteParcelable(properties[i]);
-            }
-            properties.clear();
-            break;
-        }
-        case LIST_KEYBOARD_TYPE: {
-            std::u16string imeId = data.ReadString16();
-            std::vector<KeyboardType*> kbdTypes;
-            int32_t ret = listKeyboardType(imeId, &kbdTypes);
-            if (ret != ErrorCode::NO_ERROR) {
-                reply.WriteInt32(ErrorCode::ERROR_EX_ILLEGAL_STATE);
-                reply.WriteInt32(-1);
-                return ret;
-            }
-            reply.WriteInt32(NO_ERROR);
-            int32_t size = kbdTypes.size();
-            reply.WriteInt32(size);
-            for(int32_t i=0; i<size; i++) {
-                reply.WriteParcelable(kbdTypes[i]);
-            }
-            kbdTypes.clear();
-            break;
-        }
-        default: {
-            return BRemoteObject::OnRemoteRequest(code, data, reply, option);
         }
+        return NO_ERROR;
     }
 
-    return NO_ERROR;
-}
-
-/*! Prepare input
-\n Send prepareInput command to work thread.
-    The handling of prepareInput is in the work thread of PerUserSession.
-\see PerUserSession::OnPrepareInput
-\param data the parcel in which the parameters are saved
-*/
-void InputMethodSystemAbilityStub::prepareInput(MessageParcel& data)
-{
-    IMSA_HILOGI("InputMethodSystemAbilityStub::prepareInput");
-    int32_t pid = IPCSkeleton::GetCallingPid();
-    int32_t uid = IPCSkeleton::GetCallingUid();
-    int32_t userId = getUserId(uid);
-    MessageParcel* parcel = new MessageParcel();
-    parcel->WriteInt32(userId);
-    parcel->WriteInt32(pid);
-    parcel->WriteInt32(uid);
-    parcel->WriteInt32(data.ReadInt32());
-    parcel->WriteRemoteObject(data.ReadRemoteObject());
-    parcel->WriteRemoteObject(data.ReadRemoteObject());
-    parcel->WriteParcelable(data.ReadParcelable<InputAttribute>());
-
-    Message* msg = new Message(MSG_ID_PREPARE_INPUT, parcel);
-    MessageHandler::Instance()->SendMessage(msg);
-}
-
-/*! Release input
-\n Send releaseInput command to work thread.
-    The handling of releaseInput is in the work thread of PerUserSession.
-\see PerUserSession::OnReleaseInput
-\param data the parcel in which the parameters are saved
-*/
-void InputMethodSystemAbilityStub::releaseInput(MessageParcel& data)
-{
-    IMSA_HILOGE("InputMethodSystemAbilityStub::releaseInput");
-    int32_t uid = IPCSkeleton::GetCallingUid();
-    int32_t userId = getUserId(uid);
-    MessageParcel* parcel = new MessageParcel();
-    parcel->WriteInt32(userId);
-    parcel->WriteRemoteObject(data.ReadRemoteObject());
-
-    Message* msg = new Message(MSG_ID_RELEASE_INPUT, parcel);
-    MessageHandler::Instance()->SendMessage(msg);
-
-}
-
-/*! Start input
-\n Send startInput command to work thread.
-    The handling of startInput is in the work thread of PerUserSession.
-\see PerUserSession::OnStartInput
-\param data the parcel in which the parameters are saved
-*/
-void InputMethodSystemAbilityStub::startInput(MessageParcel& data)
-{
-    int32_t uid = IPCSkeleton::GetCallingUid();
-    int32_t userId = getUserId(uid);
-    MessageParcel* parcel = new MessageParcel();
-    parcel->WriteInt32(userId);
-    parcel->WriteRemoteObject(data.ReadRemoteObject());
-
-    Message* msg = new Message(MSG_ID_START_INPUT, parcel);
-    MessageHandler::Instance()->SendMessage(msg);
-}
-
-/*! Stop input
-\n Send stopInput command to work thread.
-    The handling of stopInput is in the work thread of PerUserSession.
-\see PerUserSession::OnStopInput
-\param data the parcel in which the parameters are saved
-*/
-void InputMethodSystemAbilityStub::stopInput(MessageParcel& data)
-{
-    int32_t uid = IPCSkeleton::GetCallingUid();
-    int32_t userId = getUserId(uid);
-    MessageParcel* parcel = new MessageParcel();
-    parcel->WriteInt32(userId);
-    parcel->WriteRemoteObject(data.ReadRemoteObject());
-
-    Message* msg = new Message(MSG_ID_STOP_INPUT, parcel);
-    MessageHandler::Instance()->SendMessage(msg);
-}
-
     /*! Prepare input
-\n Send prepareInput command to work thread.
-    The handling of prepareInput is in the work thread of PerUserSession.
-\see PerUserSession::OnPrepareInput
-\param data the parcel in which the parameters are saved
-*/
-    void InputMethodSystemAbilityStub::setInputMethodCoreFromHap(MessageParcel& data)
+    \n Send prepareInput command to work thread.
+        The handling of prepareInput is in the work thread of PerUserSession.
+    \see PerUserSession::OnPrepareInput
+    \param data the parcel in which the parameters are saved
+    */
+    void InputMethodSystemAbilityStub::prepareInput(MessageParcel& data)
     {
-        IMSA_HILOGI("InputMethodSystemAbilityStub::setInputMethodCoreFromHap");
+        IMSA_HILOGI("InputMethodSystemAbilityStub::prepareInput");
+        int32_t pid = IPCSkeleton::GetCallingPid();
+        int32_t uid = IPCSkeleton::GetCallingUid();
+        int32_t userId = getUserId(uid);
+        MessageParcel* parcel = new MessageParcel();
+        parcel->WriteInt32(userId);
+        parcel->WriteInt32(pid);
+        parcel->WriteInt32(uid);
+        parcel->WriteInt32(data.ReadInt32());
+        parcel->WriteRemoteObject(data.ReadRemoteObject());
+        parcel->WriteRemoteObject(data.ReadRemoteObject());
+        parcel->WriteParcelable(data.ReadParcelable<InputAttribute>());
+
+        Message* msg = new Message(MSG_ID_PREPARE_INPUT, parcel);
+        MessageHandler::Instance()->SendMessage(msg);
+    }
+
+    /*! Release input
+    \n Send releaseInput command to work thread.
+        The handling of releaseInput is in the work thread of PerUserSession.
+    \see PerUserSession::OnReleaseInput
+    \param data the parcel in which the parameters are saved
+    */
+    void InputMethodSystemAbilityStub::releaseInput(MessageParcel& data)
+    {
+        IMSA_HILOGE("InputMethodSystemAbilityStub::releaseInput");
         int32_t uid = IPCSkeleton::GetCallingUid();
         int32_t userId = getUserId(uid);
         MessageParcel* parcel = new MessageParcel();
         parcel->WriteInt32(userId);
         parcel->WriteRemoteObject(data.ReadRemoteObject());
 
-        Message* msg = new Message(MSG_ID_SET_INPUT_METHOD_CORE, parcel);
+        Message* msg = new Message(MSG_ID_RELEASE_INPUT, parcel);
+        MessageHandler::Instance()->SendMessage(msg);
+
+    }
+
+    /*! Start input
+    \n Send startInput command to work thread.
+        The handling of startInput is in the work thread of PerUserSession.
+    \see PerUserSession::OnStartInput
+    \param data the parcel in which the parameters are saved
+    */
+    void InputMethodSystemAbilityStub::startInput(MessageParcel& data)
+    {
+        int32_t uid = IPCSkeleton::GetCallingUid();
+        int32_t userId = getUserId(uid);
+        MessageParcel* parcel = new MessageParcel();
+        parcel->WriteInt32(userId);
+        parcel->WriteRemoteObject(data.ReadRemoteObject());
+
+        Message* msg = new Message(MSG_ID_START_INPUT, parcel);
         MessageHandler::Instance()->SendMessage(msg);
     }
 
-/*! Get user id from uid
-\param uid the uid from which the remote call is
-\return return user id of the remote caller
-*/
-int32_t InputMethodSystemAbilityStub::getUserId(int32_t uid)
-{
-    return uid/1000000;
-}
-}
+    /*! Stop input
+    \n Send stopInput command to work thread.
+        The handling of stopInput is in the work thread of PerUserSession.
+    \see PerUserSession::OnStopInput
+    \param data the parcel in which the parameters are saved
+    */
+    void InputMethodSystemAbilityStub::stopInput(MessageParcel& data)
+    {
+        int32_t uid = IPCSkeleton::GetCallingUid();
+        int32_t userId = getUserId(uid);
+        MessageParcel* parcel = new MessageParcel();
+        parcel->WriteInt32(userId);
+        parcel->WriteRemoteObject(data.ReadRemoteObject());
+
+        Message* msg = new Message(MSG_ID_STOP_INPUT, parcel);
+        MessageHandler::Instance()->SendMessage(msg);
+    }
+
+        /*! Prepare input
+    \n Send prepareInput command to work thread.
+        The handling of prepareInput is in the work thread of PerUserSession.
+    \see PerUserSession::OnPrepareInput
+    \param data the parcel in which the parameters are saved
+    */
+        void InputMethodSystemAbilityStub::setInputMethodCoreFromHap(MessageParcel& data)
+        {
+            IMSA_HILOGI("InputMethodSystemAbilityStub::setInputMethodCoreFromHap");
+            int32_t uid = IPCSkeleton::GetCallingUid();
+            int32_t userId = getUserId(uid);
+            MessageParcel* parcel = new MessageParcel();
+            parcel->WriteInt32(userId);
+            parcel->WriteRemoteObject(data.ReadRemoteObject());
+
+            Message* msg = new Message(MSG_ID_SET_INPUT_METHOD_CORE, parcel);
+            MessageHandler::Instance()->SendMessage(msg);
+        }
+
+    /*! Get user id from uid
+    \param uid the uid from which the remote call is
+    \return return user id of the remote caller
+    */
+    int32_t InputMethodSystemAbilityStub::getUserId(int32_t uid)
+    {
+        return uid/1000000;
+    }
 }
+}

services/src/keyboard_type.cpp

@@ -17,171 +17,171 @@
 
 namespace OHOS {
 namespace MiscServices {
-using namespace std;
-/*! Constructor
-*/
-KeyboardType::KeyboardType()
-{
-}
+    using namespace std;
+    /*! Constructor
+    */
+    KeyboardType::KeyboardType()
+    {
+    }
 
-/*! Constructor from another instance
-  \param type the source instance
-*/
-KeyboardType::KeyboardType(const KeyboardType& type)
-{
-    mId = type.mId;
-    mHashCode = type.mHashCode;
-    mLabelId = type.mLabelId;
-    mIconId = type.mIconId;
-    mIsAsciiCapable = type.mIsAsciiCapable;
-    mLanguage = type.mLanguage;
-    mInputSource = type.mInputSource;
-    mCustomizedValue = type.mCustomizedValue;
-}
+    /*! Constructor from another instance
+      \param type the source instance
+    */
+    KeyboardType::KeyboardType(const KeyboardType& type)
+    {
+        mId = type.mId;
+        mHashCode = type.mHashCode;
+        mLabelId = type.mLabelId;
+        mIconId = type.mIconId;
+        mIsAsciiCapable = type.mIsAsciiCapable;
+        mLanguage = type.mLanguage;
+        mInputSource = type.mInputSource;
+        mCustomizedValue = type.mCustomizedValue;
+    }
 
-/*! Destructor
-*/
-KeyboardType::~KeyboardType()
-{
-}
+    /*! Destructor
+    */
+    KeyboardType::~KeyboardType()
+    {
+    }
+
+    /*! Get value from another instance
+      \param type source instance
+      \return return this
+    */
+    KeyboardType& KeyboardType::operator=(const KeyboardType& type)
+    {
+        if (this == &type) {
+            return *this;
+        }
+
+        mId = type.mId;
+        mHashCode = type.mHashCode;
+        mLabelId = type.mLabelId;
+        mIconId = type.mIconId;
+        mIsAsciiCapable = type.mIsAsciiCapable;
+        mLanguage = type.mLanguage;
+        mInputSource = type.mInputSource;
+        mCustomizedValue = type.mCustomizedValue;
 
-/*! Get value from another instance
-  \param type source instance
-  \return return this
-*/
-KeyboardType& KeyboardType::operator=(const KeyboardType& type)
-{
-    if (this == &type) {
         return *this;
     }
 
-    mId = type.mId;
-    mHashCode = type.mHashCode;
-    mLabelId = type.mLabelId;
-    mIconId = type.mIconId;
-    mIsAsciiCapable = type.mIsAsciiCapable;
-    mLanguage = type.mLanguage;
-    mInputSource = type.mInputSource;
-    mCustomizedValue = type.mCustomizedValue;
-
-    return *this;
-}
-
-/*! Write the details of object to parcel
-*/
-bool KeyboardType::Marshalling(Parcel &parcel) const
-{
-    if (!(parcel.WriteInt32(mId)
-            && parcel.WriteInt32(mHashCode)
-            && parcel.WriteInt32(mLabelId)
-            && parcel.WriteInt32(mIconId)
-            && parcel.WriteBool(mIsAsciiCapable)
-            && parcel.WriteString16(mLanguage)
-            && parcel.WriteString16(mInputSource)
-            && parcel.WriteString16(mCustomizedValue))) 
-        return false;
-    return true;
-}
-
-/*! Read the details of object from parcel
-  \param parcel read the details of object from this parcel
-  \return ErrorCode::NO_ERROR
-  \return ErrorCode::ERROR_NULL_POINTER parcel is null
-*/
-KeyboardType* KeyboardType::Unmarshalling(Parcel &parcel)
-{
-    auto info = new KeyboardType();
-    info->mId = parcel.ReadInt32();
-    info->mHashCode = parcel.ReadInt32();
-    info->mLabelId = parcel.ReadInt32();
-    info->mIconId = parcel.ReadInt32();
-    info->mIsAsciiCapable = parcel.ReadBool();
-    info->mLanguage = parcel.ReadString16();
-    info->mInputSource = parcel.ReadString16();
-    info->mCustomizedValue = parcel.ReadString16();
-    return info;
-}
-
-void KeyboardType::setId(int32_t typeId)
-{
-    mId = typeId;
-    if (typeId != ID_NONE) {
-      mHashCode = typeId;
-    } else {
-      mHashCode = ID_NONE;
+    /*! Write the details of object to parcel
+    */
+    bool KeyboardType::Marshalling(Parcel &parcel) const
+    {
+        if (!(parcel.WriteInt32(mId)
+                && parcel.WriteInt32(mHashCode)
+                && parcel.WriteInt32(mLabelId)
+                && parcel.WriteInt32(mIconId)
+                && parcel.WriteBool(mIsAsciiCapable)
+                && parcel.WriteString16(mLanguage)
+                && parcel.WriteString16(mInputSource)
+                && parcel.WriteString16(mCustomizedValue)))
+            return false;
+        return true;
     }
-    
-}
 
-void KeyboardType::setLabelId(int32_t labelId)
-{
-  mLabelId = labelId;
-}
+    /*! Read the details of object from parcel
+      \param parcel read the details of object from this parcel
+      \return ErrorCode::NO_ERROR
+      \return ErrorCode::ERROR_NULL_POINTER parcel is null
+    */
+    KeyboardType* KeyboardType::Unmarshalling(Parcel &parcel)
+    {
+        auto info = new KeyboardType();
+        info->mId = parcel.ReadInt32();
+        info->mHashCode = parcel.ReadInt32();
+        info->mLabelId = parcel.ReadInt32();
+        info->mIconId = parcel.ReadInt32();
+        info->mIsAsciiCapable = parcel.ReadBool();
+        info->mLanguage = parcel.ReadString16();
+        info->mInputSource = parcel.ReadString16();
+        info->mCustomizedValue = parcel.ReadString16();
+        return info;
+    }
 
-void KeyboardType::setIconId(int32_t iconId)
-{
-  mIconId = iconId;
-}
+    void KeyboardType::setId(int32_t typeId)
+    {
+        mId = typeId;
+        if (typeId != ID_NONE) {
+          mHashCode = typeId;
+        } else {
+          mHashCode = ID_NONE;
+        }
 
-void KeyboardType::setAsciiCapability(bool isAsciiCapable)
-{
-  mIsAsciiCapable = isAsciiCapable;
-}
+    }
 
-void KeyboardType::setLanguage(u16string language)
-{
-  mLanguage = language;
-}
+    void KeyboardType::setLabelId(int32_t labelId)
+    {
+      mLabelId = labelId;
+    }
 
-void KeyboardType::setInputSource(u16string inputSource)
-{
-  mInputSource = inputSource;
-}
+    void KeyboardType::setIconId(int32_t iconId)
+    {
+      mIconId = iconId;
+    }
 
-void KeyboardType::setCustomizedValue(u16string keyBoardTypeCustomizedValue)
-{
-  mCustomizedValue = keyBoardTypeCustomizedValue;
-}
+    void KeyboardType::setAsciiCapability(bool isAsciiCapable)
+    {
+      mIsAsciiCapable = isAsciiCapable;
+    }
 
-int32_t KeyboardType::getId() const
-{
-  return mId;
-}
+    void KeyboardType::setLanguage(u16string language)
+    {
+      mLanguage = language;
+    }
 
-int32_t KeyboardType::getLabelId() const
-{
-  return mLabelId;
-}
+    void KeyboardType::setInputSource(u16string inputSource)
+    {
+      mInputSource = inputSource;
+    }
 
-int32_t KeyboardType::getIconId() const
-{
-  return mIconId;
-}
+    void KeyboardType::setCustomizedValue(u16string keyBoardTypeCustomizedValue)
+    {
+      mCustomizedValue = keyBoardTypeCustomizedValue;
+    }
 
-/*! Get hash code of the object
-  \return return hashCode value
-*/
-int KeyboardType::getHashCode() const
-{
-  return mHashCode;
-}
+    int32_t KeyboardType::getId() const
+    {
+      return mId;
+    }
 
-/*! Get language of the object
-  \return return the language of this object
-*/
-u16string KeyboardType::getLanguage() const
-{
-  return mLanguage;
-}
+    int32_t KeyboardType::getLabelId() const
+    {
+      return mLabelId;
+    }
 
-u16string KeyboardType::getInputSource() const
-{
-  return mInputSource;
-}
+    int32_t KeyboardType::getIconId() const
+    {
+      return mIconId;
+    }
 
-u16string KeyboardType::getCustomizedValue() const
-{
-  return mCustomizedValue;
-}
+    /*! Get hash code of the object
+      \return return hashCode value
+    */
+    int KeyboardType::getHashCode() const
+    {
+      return mHashCode;
+    }
+
+    /*! Get language of the object
+      \return return the language of this object
+    */
+    u16string KeyboardType::getLanguage() const
+    {
+      return mLanguage;
+    }
+
+    u16string KeyboardType::getInputSource() const
+    {
+      return mInputSource;
+    }
+
+    u16string KeyboardType::getCustomizedValue() const
+    {
+      return mCustomizedValue;
+    }
 }
 }

services/src/message.cpp

@@ -17,57 +17,56 @@
 
 namespace OHOS {
 namespace MiscServices {
-/*! Constructor
-\param msgId a message Id
-\param msgContent the content of a message
-*/
-Message::Message(int32_t msgId, MessageParcel* msgContent)
-{
-    msgId_ = msgId;
-    msgContent_ = msgContent;
-    if (msgContent_) {
-        msgContent_->RewindRead(0);
+    /*! Constructor
+    \param msgId a message Id
+    \param msgContent the content of a message
+    */
+    Message::Message(int32_t msgId, MessageParcel* msgContent)
+    {
+        msgId_ = msgId;
+        msgContent_ = msgContent;
+        if (msgContent_) {
+            msgContent_->RewindRead(0);
+        }
     }
-}
 
-/*! Constructor
-\param msg a source message
-*/
-Message::Message(const Message& msg)
-{
-    msgId_ = msg.msgId_;
-    if (msgContent_ != nullptr) {
-        delete msgContent_;
+    /*! Constructor
+    \param msg a source message
+    */
+    Message::Message(const Message& msg)
+    {
+        msgId_ = msg.msgId_;
+        if (msgContent_ != nullptr) {
+            delete msgContent_;
+        }
+        MessageParcel* src = msg.msgContent_;
+        if (src) {
+            msgContent_ = new MessageParcel();
+            msgContent_->ParseFrom(src->GetData(), src->GetDataSize());
+        }
     }
-    MessageParcel* src = msg.msgContent_;
-    if (src) {
-        msgContent_ = new MessageParcel();
-        msgContent_->ParseFrom(src->GetData(), src->GetDataSize());
-//        msgContent_->RewindRead(0);
-    }
-}
 
-Message& Message::operator=(const Message& msg)
-{
-    if (this == &msg) {
+    Message& Message::operator=(const Message& msg)
+    {
+        if (this == &msg) {
+            return *this;
+        }
+        msgId_ = msg.msgId_;
+        if (msgContent_ != nullptr) {
+            delete msgContent_;
+        }
+        if (msg.msgContent_) {
+            msgContent_ = new MessageParcel();
+            msgContent_->ParseFrom(msg.msgContent_->GetData(), msg.msgContent_->GetDataSize());
+            msgContent_->RewindRead(0);
+        }
         return *this;
     }
-    msgId_ = msg.msgId_;
-    if (msgContent_ != nullptr) {
-        delete msgContent_;
-    }
-    if (msg.msgContent_) {
-        msgContent_ = new MessageParcel();
-        msgContent_->ParseFrom(msg.msgContent_->GetData(), msg.msgContent_->GetDataSize());
-        msgContent_->RewindRead(0);
-    }
-    return *this;
-}
 
-Message::~Message( ) {
-    if (msgContent_) {
-        delete msgContent_;
+    Message::~Message( ) {
+        if (msgContent_) {
+            delete msgContent_;
+        }
     }
 }
-}
 }

services/src/peruser_session.cpp

@@ -335,7 +335,7 @@ namespace MiscServices {
         mapClients.insert(std::pair<sptr<IRemoteObject>, ClientInfo*>(obj, clientInfo));
         int ret = obj->AddDeathRecipient(clientDeathRecipient);
         if (ret != ErrorCode::NO_ERROR) {
-            IMSA_HILOGE("PerUserSession::AddClient AddDeathRecipient return : %{public}s [%{public}d]", ErrorCode::ToString(ret), userId_);
+            IMSA_HILOGE("PerUserSession::AddClient AddDeathRecipient return : %{public}s", ErrorCode::ToString(ret));
         }
         return ErrorCode::NO_ERROR;
     }
@@ -354,18 +354,18 @@ namespace MiscServices {
         sptr<IRemoteObject> b = inputClient->AsObject();
         std::map<sptr<IRemoteObject>, ClientInfo*>::iterator it = mapClients.find(b);
         if (it == mapClients.end()) {
-            IMSA_HILOGE("PerUserSession::RemoveClient %{public}s [%{public}d]", ErrorCode::ToString(ErrorCode::ERROR_CLIENT_NOT_FOUND), userId_);
+            IMSA_HILOGE("PerUserSession::RemoveClient ErrorCode::ERROR_CLIENT_NOT_FOUND");
             return ErrorCode::ERROR_CLIENT_NOT_FOUND;
         }
         ClientInfo* clientInfo = it->second;
         bool flag = clientInfo->attribute.GetSecurityFlag();
         int ret = b->RemoveDeathRecipient(clientDeathRecipient);
         if (ret != ErrorCode::NO_ERROR) {
-            IMSA_HILOGE("PerUserSession::RemoveClient RemoveDeathRecipient return : %{public}s [%{public}d]\n", ErrorCode::ToString(ret), userId_);
+            IMSA_HILOGE("PerUserSession::RemoveClient RemoveDeathRecipient return : %{public}s", ErrorCode::ToString(ret));
         }
         ret = clientInfo->client->onInputReleased(0);
         if (ret != ErrorCode::NO_ERROR) {
-            IMSA_HILOGE("PerUserSession::RemoveClient  onInputReleased return : %{public}s [%{public}d]\n", ErrorCode::ToString(ret), userId_);
+            IMSA_HILOGE("PerUserSession::RemoveClient  onInputReleased return : %{public}s", ErrorCode::ToString(ret));
         }
         delete clientInfo;
         mapClients.erase(it);
@@ -405,7 +405,7 @@ namespace MiscServices {
         inputControlChannel[index] = localControlChannel[index];
         int ret_init = imsCore[index]->initializeInput(inputMethodToken[index], displayId, inputControlChannel[index]);
         if (ret_init != ErrorCode::NO_ERROR) {
-            IMSA_HILOGE("PerUserSession::StartInputMethod initializeInput return : %{public}s [%{public}d]\n", ErrorCode::ToString(ret_init), userId_);
+            IMSA_HILOGE("PerUserSession::StartInputMethod initializeInput return : %{public}s", ErrorCode::ToString(ret_init));
             localControlChannel[index] = nullptr;
             inputControlChannel[index] = nullptr;
             return ret_init;
@@ -425,11 +425,11 @@ namespace MiscServices {
     {
         IMSA_HILOGI("Start... index = %{public}d [%{public}d]\n", index, userId_);
         if (index >= MAX_IME || index < 0) {
-            IMSA_HILOGE("Aborted! %{public}s [%{public}d]\n", ErrorCode::ToString(ErrorCode::ERROR_BAD_PARAMETERS), userId_);
+            IMSA_HILOGE("Aborted! %{public}s", ErrorCode::ToString(ErrorCode::ERROR_BAD_PARAMETERS));
             return ErrorCode::ERROR_BAD_PARAMETERS;
         }
         if (imsCore[index] == nullptr || currentIme[index] == nullptr) {
-            IMSA_HILOGE("Aborted! %{public}s [%{public}d]\n", ErrorCode::ToString(ErrorCode::ERROR_IME_NOT_STARTED), userId_);
+            IMSA_HILOGE("Aborted! %{public}s", ErrorCode::ToString(ErrorCode::ERROR_IME_NOT_STARTED));
             return ErrorCode::ERROR_IME_NOT_STARTED;
         }
         if (currentIme[index] == currentIme[1-index] && imsCore[1-index] != nullptr) {
@@ -491,7 +491,7 @@ namespace MiscServices {
             IMSA_HILOGE("PerUserSession::ShowKeyboard Aborted! client is not ready");
             int result = clientInfo->client->onInputReady(1, nullptr, nullptr);
             if (result != ErrorCode::NO_ERROR) {
-                IMSA_HILOGE("PerUserSession::ShowKeyboard onInputReady return : %{public}s [%{public}d]\n", ErrorCode::ToString(ret), userId_);
+                IMSA_HILOGE("PerUserSession::ShowKeyboard onInputReady return : %{public}s", ErrorCode::ToString(ret));
             }
             return ErrorCode::ERROR_IME_START_FAILED;
         }
@@ -534,7 +534,7 @@ namespace MiscServices {
         IMSA_HILOGI("PerUserSession::HideKeyboard");
         int index = GetImeIndex(inputClient);
         if (index == -1) {
-            IMSA_HILOGE("PerUserSession::HideKeyboard Aborted! %{public}s [%{public}d]\n", ErrorCode::ToString(ErrorCode::ERROR_CLIENT_NOT_FOUND), userId_);
+            IMSA_HILOGE("PerUserSession::HideKeyboard Aborted! ErrorCode::ERROR_CLIENT_NOT_FOUND");
             return ErrorCode::ERROR_CLIENT_NOT_FOUND;
         }
         ClientInfo* clientInfo = GetClientInfo(inputClient);
@@ -549,7 +549,7 @@ namespace MiscServices {
 
         if (currentClient == nullptr) {
             clientInfo->client->onInputReady(1, nullptr, nullptr);
-            IMSA_HILOGE("PerUserSession::HideKeyboard Aborted! %{public}s [%{public}d]\n", ErrorCode::ToString(ErrorCode::ERROR_KBD_IS_NOT_SHOWING), userId_);
+            IMSA_HILOGE("PerUserSession::HideKeyboard Aborted! ErrorCode::ERROR_KBD_IS_NOT_SHOWING");
             return ErrorCode::ERROR_KBD_IS_NOT_SHOWING;
         }
         bool ret = imsCore[index]->hideKeyboard(1);
@@ -560,7 +560,7 @@ namespace MiscServices {
 
         int ret_client_stop = clientInfo->client->onInputReady(1, nullptr, nullptr);
         if (ret_client_stop != ErrorCode::NO_ERROR) {
-            IMSA_HILOGE("PerUserSession::HideKeyboard onInputReady return : %{public}s [%{public}d]\n", ErrorCode::ToString(ret_client_stop), userId_);
+            IMSA_HILOGE("PerUserSession::HideKeyboard onInputReady return : %{public}s", ErrorCode::ToString(ret_client_stop));
         }
         currentClient = nullptr;
         imsAgent = nullptr;
@@ -593,7 +593,7 @@ namespace MiscServices {
         if (imsCore[lastImeIndex] != nullptr) {
             int ret = imsCore[lastImeIndex]->getKeyboardWindowHeight(retHeight);
             if (ret != ErrorCode::NO_ERROR) {
-                IMSA_HILOGE("getKeyboardWindowHeight return : %{public}s [%{public}d]\n", ErrorCode::ToString(ret), userId_);
+                IMSA_HILOGE("getKeyboardWindowHeight return : %{public}s", ErrorCode::ToString(ret));
             }
             return ret;
         }
@@ -727,7 +727,9 @@ namespace MiscServices {
         }
         std::u16string currentValue = inputMethodSetting->GetValue(key);
 
-        IMSA_HILOGD("%{public}s=%{public}s, currentValue = %{public}s\n", Utils::to_utf8(key).c_str(), Utils::to_utf8(value).c_str(), Utils::to_utf8(currentValue).c_str());
+        IMSA_HILOGD("PerUserSession::OnSettingChanged key = %{public}s", Utils::to_utf8(key).c_str());
+        IMSA_HILOGD("PerUserSession::OnSettingChanged value = %{public}s", Utils::to_utf8(value).c_str());
+        IMSA_HILOGD("PerUserSession::OnSettingChanged currentValue = %{public}s", Utils::to_utf8(currentValue).c_str());
 
         if (currentValue == value) {
             IMSA_HILOGI("End...[%{public}d]\n", userId_);
@@ -947,7 +949,7 @@ namespace MiscServices {
             if (clientInfo != nullptr) {
                 int ret = clientInfo->client->onInputReleased(0);
                 if (ret != ErrorCode::NO_ERROR) {
-                    IMSA_HILOGE("2-onInputReleased return : %{public}s [%{public}d]\n", ErrorCode::ToString(ret), userId_);
+                    IMSA_HILOGE("2-onInputReleased return : %{public}s", ErrorCode::ToString(ret));
                 }
                 delete clientInfo;
             }
@@ -962,14 +964,14 @@ namespace MiscServices {
         needReshowClient = nullptr;
     }
 
-    /*! Print the session information of this user into the given stream
-    \n The information includes:
-    \li the information of all the input clients connected to the input method management system.
-    \li current input method engine information
-    \li security input method engine information
-    \li current session information
-    \param fd the raw file descriptor that the dump is being sent to
-    */
+    /* Print the session information of this user into the given stream
+     * The information includes:
+     * the information of all the input clients connected to the input method management system.
+     * current input method engine information
+     * security input method engine information
+     * current session information
+     * param fd the raw file descriptor that the dump is being sent to
+     */
     void PerUserSession::Dump(int fd)
     {
         std::map<sptr<IRemoteObject>, ClientInfo*>::const_iterator it;
@@ -1163,8 +1165,7 @@ namespace MiscServices {
                 }
             }
             if (flag == false) {
-                IMSA_HILOGW("The current keyboard type [hashCode=%{public}d] is not found in the current IME. Reset it! [%{public}d]\n",
-                    hashCode, userId_);
+                IMSA_HILOGW("The current keyboard type is not found in the current IME. Reset it!");
                 type = GetKeyboardType(imeIndex, currentKbdIndex[imeIndex]);
             } else if (imsCore[imeIndex] == imsCore[1-imeIndex]) {
                 currentKbdIndex[1-imeIndex] = currentKbdIndex[imeIndex];
@@ -1314,7 +1315,7 @@ namespace MiscServices {
 
         int ret = AddClient(pid, uid, displayId, client, channel, *attribute);
         if (ret != ErrorCode::NO_ERROR) {
-            IMSA_HILOGE("PerUserSession::OnPrepareInput Aborted! %{public}s [%{public}d]\n", ErrorCode::ToString(ret), userId_);
+            IMSA_HILOGE("PerUserSession::OnPrepareInput Aborted! %{public}s", ErrorCode::ToString(ret));
             return;
         }
         SetDisplayId(displayId);
@@ -1363,7 +1364,7 @@ namespace MiscServices {
         sptr<InputClientProxy> client = new InputClientProxy(clientObject);
         int ret = ShowKeyboard(client);
         if (ret != ErrorCode::NO_ERROR) {
-            IMSA_HILOGE("PerUserSession::OnStartInput Aborted! %{public}s [%{public}d]\n", ErrorCode::ToString(ret), userId_);
+            IMSA_HILOGE("PerUserSession::OnStartInput Aborted! %{public}s", ErrorCode::ToString(ret));
         } else {
             IMSA_HILOGI("PerUserSession::OnStartInput End...[%{public}d]\n", userId_);
         }
@@ -1379,17 +1380,17 @@ namespace MiscServices {
         int index = currentIndex;
         IMSA_HILOGI("PerUserSession::onSetInputMethodCore index = [%{public}d]\n", index);
         if (index >= MAX_IME || index < 0) {
-            IMSA_HILOGE("PerUserSession::onSetInputMethodCore Aborted! %{public}s [%{public}d]\n", ErrorCode::ToString(ErrorCode::ERROR_BAD_PARAMETERS), userId_);
+            IMSA_HILOGE("PerUserSession::onSetInputMethodCore Aborted! ErrorCode::ERROR_BAD_PARAMETERS");
             return;
         }
         if (imsCore[index] != nullptr) {
-            IMSA_HILOGI("PerUserSession::onSetInputMethodCore End... Input Method Service has already been started ! [%{public}d]\n", userId_);
+            IMSA_HILOGI("PerUserSession::onSetInputMethodCore End... Input Method Service has already been started ! ");
             return;
         }
         imsCore[index]=core;
         int ret = StartInputMethod(index);
         if (ret != ErrorCode::NO_ERROR) {
-            IMSA_HILOGE("PerUserSession::onSetInputMethodCore Aborted! %{public}s [%{public}d]\n", ErrorCode::ToString(ret), userId_);
+            IMSA_HILOGE("PerUserSession::onSetInputMethodCore Aborted! %{public}s", ErrorCode::ToString(ret));
         } else {
             IMSA_HILOGI("PerUserSession::onSetInputMethodCore End...[%{public}d]\n", userId_);
         }
@@ -1409,7 +1410,7 @@ namespace MiscServices {
         sptr<InputClientProxy> client = new InputClientProxy(clientObject);
         int ret = HideKeyboard(client);
         if (ret != ErrorCode::NO_ERROR) {
-            IMSA_HILOGE("PerUserSession::OnStopInput Aborted! %{public}s [%{public}d]\n", ErrorCode::ToString(ret), userId_);
+            IMSA_HILOGE("PerUserSession::OnStopInput Aborted! %{public}s", ErrorCode::ToString(ret));
         } else {
             IMSA_HILOGI("PerUserSession::OnStopInput End...[%{public}d]\n", userId_);
         }

services/src/peruser_setting.cpp

@@ -13,7 +13,6 @@
  * limitations under the License.
  */
  
- 
 #include "unistd.h"   //usleep
 #include "peruser_setting.h"
 #include "platform.h"
@@ -23,8 +22,7 @@ namespace MiscServices {
     /*! Constructor
     \param userId the id number of this user
     */
-    PerUserSetting::PerUserSetting(int userId)
-    {
+    PerUserSetting::PerUserSetting(int userId) {
         userId_ = userId;
         currentImeId = Utils::to_utf16("");
         userState = UserState::USER_STATE_STARTED;
@@ -39,13 +37,12 @@ namespace MiscServices {
         }
     }
 
-    /*! Initialize data for this user.
-    \n It's called when this user is unlocked. The work includes:
-    \li read all installed input method engine information from the system
-    \li read input method setting data from the system
-    */
-    void PerUserSetting::Initialize()
-    {
+    /* Initialize data for this user.
+     * It's called when this user is unlocked. The work includes:
+     * read all installed input method engine information from the system
+     * read input method setting data from the system
+     */
+    void PerUserSetting::Initialize() {
         userState = UserState::USER_STATE_UNLOCKED;
 
         inputMethodProperties.clear();
@@ -76,8 +73,7 @@ namespace MiscServices {
     \return ErrorCode::ERROR_NOT_IME_PACKAGE The installed package is not an IME package.
     \return ErrorCode::ERROR_IME_PACKAGE_DUPLICATED The installed package is duplicated.
     */
-    int PerUserSetting::OnPackageAdded(std::u16string& packageName, bool* isSecurityIme)
-    {
+    int PerUserSetting::OnPackageAdded(std::u16string& packageName, bool* isSecurityIme) {
         if (isSecurityIme) {
             *isSecurityIme = false;
         }
@@ -123,8 +119,7 @@ namespace MiscServices {
     \return ErrorCode::NO_ERROR The removed package is an IME package, and is removed from the input method management system
     \return ErrorCode::ERROR_NOT_IME_PACKAGE The removed package is not an IME package.
     */
-    int PerUserSetting::OnPackageRemoved(std::u16string& packageName, bool* isSecurityIme)
-    {
+    int PerUserSetting::OnPackageRemoved(std::u16string& packageName, bool* isSecurityIme) {
         if (isSecurityIme) {
             *isSecurityIme = false;
         }
@@ -175,8 +170,7 @@ namespace MiscServices {
     \return ErrorCode::NO_ERROR update the setting data to input method management system.
     \return ErrorCode::ERROR_SETTING_SAME_VALUE the current value is same as the one in the system.
     */
-    int PerUserSetting::OnSettingChanged(const std::u16string& key, const std::u16string& value)
-    {
+    int PerUserSetting::OnSettingChanged(const std::u16string& key, const std::u16string& value) {
         std::u16string currentValue = inputMethodSetting.GetValue(key);
 
         if (currentValue == value) {
@@ -203,8 +197,7 @@ namespace MiscServices {
 
     /*! Switch to the next input method service.
     */
-    void PerUserSetting::OnAdvanceToNext()
-    {
+    void PerUserSetting::OnAdvanceToNext() {
         bool flag = false;
         std::u16string enabledInputMethods = inputMethodSetting.GetValue(InputMethodSetting::ENABLED_INPUT_METHODS_TAG);
         std::u16string imeId;
@@ -240,13 +233,12 @@ namespace MiscServices {
         Platform::Instance()->SetInputMethodSetting(userId_, tmpSetting);
     }
 
-    /*! It's Called when this user is locked.
-    \n Release data for this user including:
-    \li release input method engine information
-    \li release input method setting data
-    */
-    void PerUserSetting::OnUserLocked()
-    {
+    /* It's Called when this user is locked.
+     * Release data for this user including:
+     * release input method engine information
+     * release input method setting data
+     */
+    void PerUserSetting::OnUserLocked() {
         if (userState == UserState::USER_STATE_STARTED) {
             return;
         }
@@ -267,15 +259,14 @@ namespace MiscServices {
         inputMethodSetting.ClearData();
     }
 
-    /*! Print the related information for this user into the given stream
-    \n The information includes:
-    \li The user id and user state
-    \li The information of all input method engine installed in the system
-    \li The input method setting data of this user.
-    \param fd the raw file descriptor that the dump is being sent to
-    */
-    void PerUserSetting::Dump(int fd)
-    {
+    /* Print the related information for this user into the given stream
+     * The information includes:
+     * The user id and user state
+     * The information of all input method engine installed in the system
+     * The input method setting data of this user.
+     * param fd the raw file descriptor that the dump is being sent to
+     */
+    void PerUserSetting::Dump(int fd) {
         int size = inputMethodProperties.size();
         dprintf(fd, "\n - User Setting State :\n");
         dprintf(fd, " * Installed IME count = %d\n", size);
@@ -302,8 +293,7 @@ namespace MiscServices {
     \return UserState::USER_STATE_STARTED user is started
     \return UserState::USER_STATE_UNLOCKED user is unlocked
     */
-    int PerUserSetting::GetUserState()
-    {
+    int PerUserSetting::GetUserState() {
         return userState;
     }
 
@@ -312,8 +302,7 @@ namespace MiscServices {
     \return null when there is no enabled IME in the system.
     \note The returned pointer should NOT be freed by caller
     */
-    InputMethodProperty* PerUserSetting::GetCurrentInputMethod()
-    {
+    InputMethodProperty* PerUserSetting::GetCurrentInputMethod() {
         for(int i=0; i<(int)inputMethodProperties.size(); i++) {
             if (currentImeId == inputMethodProperties[i]->mImeId) {
                 return inputMethodProperties[i];
@@ -328,8 +317,7 @@ namespace MiscServices {
     \return null when there is no security IME in the system.
     \note The returned pointer should NOT be freed by caller
     */
-    InputMethodProperty* PerUserSetting::GetSecurityInputMethod()
-    {
+    InputMethodProperty* PerUserSetting::GetSecurityInputMethod() {
         InputMethodProperty* ime = nullptr;
         std::u16string systemLocales = inputMethodSetting.GetValue(InputMethodSetting::SYSTEM_LOCALE_TAG);
         for(int i=0; i<(int)inputMethodProperties.size(); i++) {
@@ -359,8 +347,7 @@ namespace MiscServices {
     \return null when the next enabled IME is not available.
     \note The returned pointer should NOT be freed by caller
     */
-    InputMethodProperty* PerUserSetting::GetNextInputMethod()
-    {
+    InputMethodProperty* PerUserSetting::GetNextInputMethod() {
         bool flag = false;
         std::u16string enabledInputMethods = inputMethodSetting.GetValue(InputMethodSetting::ENABLED_INPUT_METHODS_TAG);
         std::u16string imeId;
@@ -384,8 +371,7 @@ namespace MiscServices {
     \return a pointer of InputMethodSetting.
     \note The returned pointer should NOT be freed by caller
     */
-    InputMethodSetting* PerUserSetting::GetInputMethodSetting()
-    {
+    InputMethodSetting* PerUserSetting::GetInputMethodSetting() {
         return &inputMethodSetting;
     }
 
@@ -393,8 +379,7 @@ namespace MiscServices {
     \param[out] properties the details will be written to the param properties
     \return ErrorCode::NO_ERROR
     */
-    int32_t PerUserSetting::ListInputMethodEnabled(std::vector<InputMethodProperty*> *properties)
-    {
+    int32_t PerUserSetting::ListInputMethodEnabled(std::vector<InputMethodProperty*> *properties) {
         std::u16string enabledInputMethods = inputMethodSetting.GetValue(InputMethodSetting::ENABLED_INPUT_METHODS_TAG);
         for(int i=0; i<(int)inputMethodProperties.size(); i++) {
 
@@ -409,8 +394,7 @@ namespace MiscServices {
     \param[out] properties the details will be written to the param properties
     \return ErrorCode::NO_ERROR
     */
-    int32_t PerUserSetting::ListInputMethod(std::vector<InputMethodProperty*> *properties)
-    {
+    int32_t PerUserSetting::ListInputMethod(std::vector<InputMethodProperty*> *properties) {
         for(int i=0; i<(int)inputMethodProperties.size(); i++) {
             properties->push_back(inputMethodProperties[i]);
         }
@@ -422,8 +406,7 @@ namespace MiscServices {
     \param[out] types the data of type list of the given IME will be written to types
     \return ErrorCode::NO_ERROR
     */
-    int32_t PerUserSetting::ListKeyboardType(const std::u16string& imeId, std::vector<KeyboardType*> *types)
-    {
+    int32_t PerUserSetting::ListKeyboardType(const std::u16string& imeId, std::vector<KeyboardType*> *types) {
         for(int i=0; i<(int)inputMethodProperties.size(); i++) {
             if (imeId == inputMethodProperties[i]->mImeId) {
                 for(int j=0; j<(int)inputMethodProperties[i]->mTypes.size(); j++) {
@@ -441,8 +424,7 @@ namespace MiscServices {
     \return null when the given IME is not available
     \note the returned pointer should not be freed by the caller.
     */
-    InputMethodProperty* PerUserSetting::GetInputMethodProperty(const std::u16string& imeId)
-    {
+    InputMethodProperty* PerUserSetting::GetInputMethodProperty(const std::u16string& imeId) {
         for(int i=0; i<(int)inputMethodProperties.size(); i++) {
             if (inputMethodProperties[i]->mImeId == imeId) {
                 return inputMethodProperties[i];
@@ -457,8 +439,7 @@ namespace MiscServices {
     \return language value when the given hashCode is found
     \return an empty string when the given hashCode is not found
     */
-    std::u16string PerUserSetting::GetKeyboardTypeLanguage(const InputMethodProperty* property, int hashCode)
-    {
+    std::u16string PerUserSetting::GetKeyboardTypeLanguage(const InputMethodProperty* property, int hashCode) {
         for(int i=0; i<(int)property->mTypes.size(); i++) {
             if (property->mTypes[i]->getHashCode() == hashCode) {
                 return property->mTypes[i]->getLanguage();
@@ -469,8 +450,7 @@ namespace MiscServices {
 
     /*! Init input method setting data
     */
-    void PerUserSetting::InitInputMethodSetting()
-    {
+    void PerUserSetting::InitInputMethodSetting() {
         bool flag = inputMethodSetting.FindKey(InputMethodSetting::ENABLED_INPUT_METHODS_TAG);
         if (flag == false) {
             for(int i=0; i<(int)inputMethodProperties.size(); i++) {
@@ -506,8 +486,7 @@ namespace MiscServices {
     \li If no system ime is there, we use the first enabled ime as current ime.
     \li If no enabled ime, set current ime as null.
     */
-    void PerUserSetting::ResetCurrentInputMethod()
-    {
+    void PerUserSetting::ResetCurrentInputMethod() {
         std::u16string systemLocales = inputMethodSetting.GetValue(InputMethodSetting::SYSTEM_LOCALE_TAG);
         std::u16string enabledInputMethods = inputMethodSetting.GetValue(InputMethodSetting::ENABLED_INPUT_METHODS_TAG);
         std::u16string imeId;
@@ -554,8 +533,7 @@ namespace MiscServices {
     \param packageName the packageName of the given IME
     \return the id of the given IME
     */
-    std::u16string PerUserSetting::GetImeId(const std::u16string& packageName)
-    {
+    std::u16string PerUserSetting::GetImeId(const std::u16string& packageName) {
         for(int i=0; i<(int)inputMethodProperties.size(); i++) {
             if (inputMethodProperties[i]->mPackageName == packageName) {
                 return inputMethodProperties[i]->mImeId;
@@ -569,8 +547,7 @@ namespace MiscServices {
     \return true - It's a security Ime
     \n      false - It's not a security Ime
     */
-    bool PerUserSetting::CheckIfSecurityIme(const InputMethodProperty& property)
-    {
+    bool PerUserSetting::CheckIfSecurityIme(const InputMethodProperty& property) {
         return property.isSystemIme;
     }
 }

services/src/platform.cpp

@@ -13,15 +13,13 @@
  * limitations under the License.
  */
 
-
 #include "global.h"
 #include "platform.h"
 #include "platform_callback_stub.h"
 
 namespace OHOS {
 namespace MiscServices {
-    void Platform::SetPlatform(const sptr < IPlatformApi >& platformApi)
-    {
+    void Platform::SetPlatform(const sptr < IPlatformApi >& platformApi) {
         this->platformApi = platformApi;
         sptr < IPlatformCallback > cb = new PlatformCallbackStub();
         this->platformApi->registerCallback(cb);
@@ -29,20 +27,17 @@ namespace MiscServices {
 
     /*! Constructor
     */
-    Platform::Platform()
-    {
+    Platform::Platform() {
     }
 
     /*! Destructor
     */
-    Platform::~Platform()
-    {
+    Platform::~Platform() {
     }
 
     /*! Single instance exists in the service
     */
-    Platform* Platform::Instance()
-    {
+    Platform* Platform::Instance() {
         static Platform* platform = nullptr;
         if (platform == nullptr) {
             platform = new Platform();
@@ -57,8 +52,7 @@ namespace MiscServices {
       \return the remote object handler of started input method service.
     */
     sptr < IInputMethodCore > Platform::BindInputMethodService(int userId, const std::u16string& packageName,
-                                                               const std::u16string& intention)
-    {
+                                                               const std::u16string& intention) {
         if (platformApi == nullptr) {
             return nullptr;
         }
@@ -70,8 +64,7 @@ namespace MiscServices {
       \param packageName the packageName of the given input method engine which is going to stop
       \return ErrorCode
     */
-    int Platform::UnbindInputMethodService(int userId, const std::u16string& packageName)
-    {
+    int Platform::UnbindInputMethodService(int userId, const std::u16string& packageName) {
         if (platformApi == nullptr) {
             return ErrorCode::ERROR_NULL_POINTER;
         }
@@ -84,8 +77,7 @@ namespace MiscServices {
       \param packageName the packageName of the given input method engine
       \return ErrorCode
     */
-    sptr < IRemoteObject > Platform::CreateWindowToken(int userId, int displayId, const std::u16string& packageName)
-    {
+    sptr < IRemoteObject > Platform::CreateWindowToken(int userId, int displayId, const std::u16string& packageName) {
         if (platformApi == nullptr) {
             return nullptr;
         }
@@ -97,8 +89,7 @@ namespace MiscServices {
       \param packageName the packageName of the given input method engine
       \return ErrorCode
     */
-    int Platform::DestroyWindowToken(int userId, const std::u16string& packageName)
-    {
+    int Platform::DestroyWindowToken(int userId, const std::u16string& packageName) {
         if (platformApi == nullptr) {
             return ErrorCode::ERROR_NULL_POINTER;
         }
@@ -110,8 +101,7 @@ namespace MiscServices {
       \param[out] inputMethodProperties the input method engine list installed in the system for the given user
       \return ErrorCode
     */
-    int Platform::ListInputMethod(int userId, std::vector < InputMethodProperty* > * inputMethodProperties)
-    {
+    int Platform::ListInputMethod(int userId, std::vector < InputMethodProperty* > * inputMethodProperties) {
         return 0;
     }
 
@@ -121,8 +111,8 @@ namespace MiscServices {
       \param[out] inputMethodProperty the input method engine information for the given package
       \return ErrorCode
     */
-    int Platform::GetInputMethodProperty(int userId, const std::u16string& packageName, InputMethodProperty * inputMethodProperty)
-    {
+    int Platform::GetInputMethodProperty(int userId, const std::u16string& packageName,
+                                         InputMethodProperty* inputMethodProperty) {
         if (platformApi == nullptr) {
             return ErrorCode::ERROR_NULL_POINTER;
         }
@@ -134,8 +124,8 @@ namespace MiscServices {
       \param[out] inputMethodSetting the input method setting data for the given user
       \return ErrorCode
     */
-    int Platform::GetInputMethodSetting(int userId, InputMethodSetting * inputMethodSetting)
-    {
+
+    int Platform::GetInputMethodSetting(int userId, InputMethodSetting* inputMethodSetting) {
         return 0;
     }
 
@@ -144,8 +134,7 @@ namespace MiscServices {
       \param inputMethodSetting the input method setting data for the given user
       \return ErrorCode
     */
-    int Platform::SetInputMethodSetting(int userId, const InputMethodSetting& inputMethodSetting)
-    {
+    int Platform::SetInputMethodSetting(int userId, const InputMethodSetting& inputMethodSetting) {
         if (platformApi == nullptr) {
             return ErrorCode::ERROR_NULL_POINTER;
         }
@@ -156,8 +145,7 @@ namespace MiscServices {
       \return true - a physical keyboard is connected
       \n      false - no physical keyboard
     */
-    bool Platform::CheckPhysicalKeyboard()
-    {
+    bool Platform::CheckPhysicalKeyboard() {
         return true;
     }
 
@@ -165,8 +153,7 @@ namespace MiscServices {
       \return true - the remote caller is from a valid window
       \n      false - the remote caller is not from a valid window
     */
-    bool Platform::IsValidWindow(int uid, int pid, int displayId)
-    {
+    bool Platform::IsValidWindow(int uid, int pid, int displayId) {
         (void)uid;
         (void)pid;
         (void)displayId;
@@ -177,8 +164,7 @@ namespace MiscServices {
       \return true - the remote caller is from a focused window
       \n      false - the remote caller is not from a focused window
     */
-    bool Platform::IsWindowFocused(int uid, int pid, int displayId)
-    {
+    bool Platform::IsWindowFocused(int uid, int pid, int displayId) {
         (void)uid;
         (void)pid;
         (void)displayId;

services/src/platform_api_proxy.cpp

@@ -24,27 +24,21 @@
 #include <string>
 #include <stdint.h>
 
-
 /*! \class PlatformApiProxy
   \brief The proxy implementation of IPlatformApi
-
-  \todo This class will be deleted on target platform
 */
 namespace OHOS {
 namespace MiscServices {
-    class PlatformApi : public IRemoteProxy < IPlatformApi > {
+    class PlatformApiProxy : public IRemoteProxy < IPlatformApi > {
     public:
-        PlatformApi(const sptr < IRemoteObject >& impl)
-        : IRemoteProxy < IPlatformApi >(impl)
-        {
+        PlatformApiProxy(const sptr<IRemoteObject>& impl)
+        : IRemoteProxy < IPlatformApi >(impl) {
         }
 
-        ~PlatformApi()
-        {
+        ~PlatformApiProxy() {
         }
 
-        int32_t registerCallback(const sptr < IPlatformCallback >& cb)
-        {
+        int32_t registerCallback(const sptr < IPlatformCallback >& cb) {
             MessageParcel data, reply;
             MessageOption option;
             data.WriteInterfaceToken(GetDescriptor());
@@ -64,8 +58,8 @@ namespace MiscServices {
             return Utils::to_utf16("20210814");
         }
 
-        sptr < IInputMethodCore > bindInputMethodService(const std::u16string& packageName, const std::u16string& intention, int userId)
-        {
+        sptr < IInputMethodCore > bindInputMethodService(const std::u16string& packageName,
+            const std::u16string& intention, int userId) {
             MessageParcel data, reply;
             MessageOption option;
             data.WriteInterfaceToken(GetDescriptor());
@@ -87,8 +81,7 @@ namespace MiscServices {
             return ims;
         }
 
-        int32_t unbindInputMethodService(int userId, const std::u16string& packageName)
-        {
+        int32_t unbindInputMethodService(int userId, const std::u16string& packageName) {
             MessageParcel data, reply;
             MessageOption option;
             data.WriteInterfaceToken(GetDescriptor());
@@ -105,8 +98,7 @@ namespace MiscServices {
             return ErrorCode::NO_ERROR;
         }
 
-        sptr < IRemoteObject > createWindowToken(int userId, int displayId, const std::u16string& packageName)
-        {
+        sptr < IRemoteObject > createWindowToken(int userId, int displayId, const std::u16string& packageName) {
             MessageParcel data, reply;
             MessageOption option;
             data.WriteInterfaceToken(GetDescriptor());
@@ -126,8 +118,7 @@ namespace MiscServices {
             return token;
         }
 
-        int32_t destroyWindowToken(int userId, const std::u16string& packageName)
-        {
+        int32_t destroyWindowToken(int userId, const std::u16string& packageName) {
             MessageParcel data, reply;
             MessageOption option;
             data.WriteInterfaceToken(GetDescriptor());
@@ -138,13 +129,14 @@ namespace MiscServices {
                 return status;
             }
             int code = reply.ReadException();
-            if (code != 0)  // code=0, means no exception.
+            if (code != 0) {
+                // code=0, means no exception.
                 return code;
+            }
             return ErrorCode::NO_ERROR;
         }
 
-        int32_t listInputMethod(int userId, std::vector < InputMethodProperty* > * inputMethodProperties)
-        {
+        int32_t listInputMethod(int userId, std::vector < InputMethodProperty* >* inputMethodProperties) {
             MessageParcel data, reply;
             MessageOption option;
             data.WriteInterfaceToken(GetDescriptor());
@@ -154,11 +146,13 @@ namespace MiscServices {
                 return status;
             }
             int code = reply.ReadException();
-            if (code != 0)  // code=0, means no exception.
+            if (code != 0) {
+                // code=0, means no exception.
                 return code;
+            }
             int size = reply.ReadInt32();
             for (int i = 0; i < size; i++) {
-                InputMethodProperty * property = new InputMethodProperty();
+                InputMethodProperty* property = new InputMethodProperty();
                 property = reply.ReadParcelable<InputMethodProperty>();
                 inputMethodProperties->push_back(property);
             }
@@ -166,8 +160,8 @@ namespace MiscServices {
         }
 
 
-        virtual int32_t getInputMethodProperty(int userId, const std::u16string& packageName, InputMethodProperty * inputMethodProperty)
-        {
+        virtual int32_t getInputMethodProperty(int userId, const std::u16string& packageName,
+            InputMethodProperty* inputMethodProperty) {
             MessageParcel data, reply;
             MessageOption option;
             data.WriteInterfaceToken(GetDescriptor());
@@ -178,14 +172,15 @@ namespace MiscServices {
                 return status;
             }
             int code = reply.ReadException();
-            if (code != 0)  // code=0, means no exception.
+            if (code != 0) {
+                // code=0, means no exception.
                 return code;
+            }
             inputMethodProperty = reply.ReadParcelable<InputMethodProperty>();
             return status;
         }
 
-        int32_t getInputMethodSetting(int userId, InputMethodSetting * inputMethodSetting)
-        {
+        int32_t getInputMethodSetting(int userId, InputMethodSetting* inputMethodSetting) {
             MessageParcel data, reply;
             MessageOption option;
             data.WriteInterfaceToken(GetDescriptor());
@@ -195,14 +190,15 @@ namespace MiscServices {
                 return status;
             }
             int code = reply.ReadException();
-            if (code != 0)  // code=0, means no exception.
+            if (code != 0) {
+                // code=0, means no exception.
                 return code;
+            }
             inputMethodSetting = reply.ReadParcelable<InputMethodSetting>();
             return status;
         }
 
-        int32_t setInputMethodSetting(int userId, const InputMethodSetting& inputMethodSetting)
-        {
+        int32_t setInputMethodSetting(int userId, const InputMethodSetting& inputMethodSetting) {
             MessageParcel data, reply;
             MessageOption option;
             data.WriteInterfaceToken(GetDescriptor());
@@ -213,8 +209,10 @@ namespace MiscServices {
                 return status;
             }
             int code = reply.ReadException();
-            if (code != 0)  // code=0, means no exception.
+            if (code != 0) {
+                // code=0, means no exception.
                 return code;
+            }
             return ErrorCode::NO_ERROR;
         }
     };

services/src/platform_callback_proxy.cpp

@@ -19,27 +19,21 @@
 #include "global.h"
 #include "i_platform_callback.h"
 
-
-
 /*! \class PlatformCallbackProxy
   \brief The proxy of IPlatformCallback
-  \todo This class will be deleted on target platform
 */
 namespace OHOS {
 namespace MiscServices {
     class PlatformCallbackProxy : public IRemoteProxy < IPlatformCallback > {
     public:
         PlatformCallbackProxy(const sptr < IRemoteObject >& impl)
-        : IRemoteProxy < IPlatformCallback >(impl)
-        {
+        : IRemoteProxy < IPlatformCallback >(impl) {
         }
 
-        ~PlatformCallbackProxy()
-        {
+        ~PlatformCallbackProxy() {
         }
 
-        void notifyEvent(int eventId, int userId, const std::vector < std::u16string >& eventContent)
-        {
+        void notifyEvent(int eventId, int userId, const std::vector < std::u16string >& eventContent) {
             (void)eventId;
             (void)userId;
             (void)eventContent;

services/src/platform_callback_stub.cpp

@@ -13,7 +13,6 @@
  * limitations under the License.
  */
 
-
 #include "message_handler.h"
 #include "message.h"
 #include "message_parcel.h"
@@ -30,7 +29,8 @@ namespace MiscServices {
     PlatformCallbackStub::~PlatformCallbackStub() {
     }
 
-    int PlatformCallbackStub::OnRemoteRequest(uint32_t code, MessageParcel & data, MessageParcel & reply, MessageOption & option) {
+    int PlatformCallbackStub::OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply,
+                                              MessageOption& option) {
         switch (code) {
             case NOTIFY_EVENT: {
                 int eventId = data.ReadInt32();
@@ -97,4 +97,4 @@ namespace MiscServices {
         MessageHandler::Instance()->SendMessage(msg);
     }
 }
-}
+}

unitest/BUILD.gn

@@ -27,7 +27,7 @@ ohos_unittest("InputMethodControllerTest") {
   module_out_path = module_output_path
 
   sources = [
-    "src/test_imc.cpp"]
+    "src/input_method_controller_test.cpp"]
 
   configs = [
     ":module_private_config",
@@ -60,7 +60,7 @@ ohos_unittest("InputMethodAbilityTest") {
   module_out_path = module_output_path
 
   sources = [
-    "src/test_ima.cpp"]
+    "src/input_method_ability_test.cpp"]
 
   configs = [
     ":module_private_config",

unitest/src/input_method_ability_test.cpp

@@ -31,14 +31,12 @@
 #include "input_method_ability.h"
 #include "message_handler.h"
 
-
 using namespace testing::ext;
 using namespace OHOS;
 using namespace OHOS::MiscServices;
 using namespace OHOS::AAFwk;
 
-class InputMethodAbilityTest : public testing::Test
-{
+class InputMethodAbilityTest : public testing::Test {
 public:
     static void SetUpTestCase(void);
     static void TearDownTestCase(void);
@@ -46,23 +44,18 @@ public:
     void TearDown();
 };
 
-
-void InputMethodAbilityTest::SetUpTestCase(void)
-{
+void InputMethodAbilityTest::SetUpTestCase(void) {
     IMSA_HILOGI("InputMethodAbilityTest::SetUpTestCase");
 }
 
-void InputMethodAbilityTest::TearDownTestCase(void)
-{
+void InputMethodAbilityTest::TearDownTestCase(void) {
     IMSA_HILOGI("InputMethodAbilityTest::TearDownTestCase");
 }
 
-void InputMethodAbilityTest::SetUp(void)
-{
+void InputMethodAbilityTest::SetUp(void) {
     IMSA_HILOGI("InputMethodAbilityTest::SetUp");
 }
 
-void InputMethodAbilityTest::TearDown(void)
-{
+void InputMethodAbilityTest::TearDown(void) {
     IMSA_HILOGI("InputMethodAbilityTest::TearDown");
 }

unitest/src/input_method_controller_test.cpp

@@ -30,7 +30,6 @@
 #include "iservice_registry.h"
 #include "system_ability_definition.h"
 
-
 using namespace testing::ext;
 using namespace OHOS;
 using namespace OHOS::MiscServices;
@@ -51,8 +50,7 @@ public:
         IMSA_HILOGI("IMC TEST TextListener SetKeyboardStatus %{public}d", status);
     }
 };
-class InputMethodControllerTest : public testing::Test
-{
+class InputMethodControllerTest : public testing::Test {
 public:
     static void SetUpTestCase(void);
     static void TearDownTestCase(void);
@@ -60,23 +58,19 @@ public:
     void TearDown();
 };
 
-void InputMethodControllerTest::SetUpTestCase(void)
-{
+void InputMethodControllerTest::SetUpTestCase(void) {
     IMSA_HILOGI("InputMethodControllerTest::SetUpTestCase");
 }
 
-void InputMethodControllerTest::TearDownTestCase(void)
-{
+void InputMethodControllerTest::TearDownTestCase(void) {
     IMSA_HILOGI("InputMethodControllerTest::TearDownTestCase");
 }
 
-void InputMethodControllerTest::SetUp(void)
-{
+void InputMethodControllerTest::SetUp(void) {
     IMSA_HILOGI("InputMethodControllerTest::SetUp");
 }
 
-void InputMethodControllerTest::TearDown(void)
-{
+void InputMethodControllerTest::TearDown(void) {
     IMSA_HILOGI("InputMethodControllerTest::TearDown");
 }
 
@@ -85,8 +79,7 @@ void InputMethodControllerTest::TearDown(void)
 * @tc.desc: Bind IMSA.
 * @tc.type: FUNC
 */
-HWTEST_F(InputMethodControllerTest, Imc001, TestSize.Level0)
-{
+HWTEST_F(InputMethodControllerTest, Imc001, TestSize.Level0) {
     IMSA_HILOGI("IMC TEST START");
     sptr<InputMethodController> imc = InputMethodController::GetInstance();
     ASSERT_TRUE(imc!=nullptr);