diff --git a/interfaces/native/include/geomagnetic_field.h b/interfaces/native/include/geomagnetic_field.h
index fbd10bf1527abd6fe6bb46a3250e38bbe8074891..2031e505e45dbb0a4ac1dc0301105f275bc19f13 100755
--- a/interfaces/native/include/geomagnetic_field.h
+++ b/interfaces/native/include/geomagnetic_field.h
@@ -33,19 +33,19 @@ public:
 
     ~GeomagneticField() = default;
 
-    float obtainX();
+    float ObtainX();
 
-    float obtainY();
+    float ObtainY();
 
-    float obtainZ();
+    float ObtainZ();
 
-    float obtainGeomagneticDip();
+    float ObtainGeomagneticDip();
 
-    float obtainDeflectionAngle();
+    float ObtainDeflectionAngle();
 
-    float obtainLevelIntensity();
+    float ObtainLevelIntensity();
 
-    float obtainTotalIntensity();
+    float ObtainTotalIntensity();
 
 private:
     float northComponent;
@@ -77,13 +77,13 @@ private:
     static std::vector<float> sinMLongitude;
     static std::vector<float> cosMLongitude;
 
-    static std::vector<std::vector<float>> getSchmidtQuasiNormalFactors(int32_t expansionDegree);
-    void calculateGeomagneticComponent(double latDiffRad, int64_t timeMillis);
-    static void getLongitudeTrigonometric();
-    static void getRelativeRadiusPower();
-    static void calibrateGeocentricCoordinates(float latitude, float longitude, float altitude);
-    void initLegendreTable(int32_t expansionDegree, float thetaRad);
-    double toDegrees(double angrad);
-    static double toRadians(double angdeg);
+    static std::vector<std::vector<float>> GetSchmidtQuasiNormalFactors(int32_t expansionDegree);
+    void CalculateGeomagneticComponent(double latDiffRad, int64_t timeMillis);
+    static void GetLongitudeTrigonometric();
+    static void GetRelativeRadiusPower();
+    static void CalibrateGeocentricCoordinates(float latitude, float longitude, float altitude);
+    void InitLegendreTable(int32_t expansionDegree, float thetaRad);
+    double ToDegrees(double angrad);
+    static double ToRadians(double angdeg);
 };
 #endif // GEOMAGNETIC_FIELD_H
\ No newline at end of file
diff --git a/interfaces/native/src/geomagnetic_field.cpp b/interfaces/native/src/geomagnetic_field.cpp
index fc77139195b7c92a5ea7a82050a2b32e5c04b626..239f16c9ca90244543c4711bf9914ec7c2eb0871 100644
--- a/interfaces/native/src/geomagnetic_field.cpp
+++ b/interfaces/native/src/geomagnetic_field.cpp
@@ -112,61 +112,61 @@ float GeomagneticField::geocentricRadius;
 
 GeomagneticField::GeomagneticField(float latitude, float longitude, float altitude, int64_t timeMillis)
 {
-    schmidtQuasiNormalFactors = getSchmidtQuasiNormalFactors(GAUSSIAN_COEFFICIENT_DIMENSION);
+    schmidtQuasiNormalFactors = GetSchmidtQuasiNormalFactors(GAUSSIAN_COEFFICIENT_DIMENSION);
     float gcLatitude = fmax(LATITUDE_MIN + PRECISION, fmin(LATITUDE_MAX - PRECISION, latitude));
-    calibrateGeocentricCoordinates(gcLatitude, longitude, altitude);
-    initLegendreTable(GAUSSIAN_COEFFICIENT_DIMENSION - 1, static_cast<float>(M_PI / 2.0 - geocentricLatitude));
-    getRelativeRadiusPower();
-    double latDiffRad = toRadians(gcLatitude) - geocentricLatitude;
-    calculateGeomagneticComponent(latDiffRad, timeMillis);
+    CalibrateGeocentricCoordinates(gcLatitude, longitude, altitude);
+    InitLegendreTable(GAUSSIAN_COEFFICIENT_DIMENSION - 1, static_cast<float>(M_PI / 2.0 - geocentricLatitude));
+    GetRelativeRadiusPower();
+    double latDiffRad = ToRadians(gcLatitude) - geocentricLatitude;
+    CalculateGeomagneticComponent(latDiffRad, timeMillis);
 }
 
-std::vector<std::vector<float>> GeomagneticField::getSchmidtQuasiNormalFactors(int32_t expansionDegree)
+std::vector<std::vector<float>> GeomagneticField::GetSchmidtQuasiNormalFactors(int32_t expansionDegree)
 {
     std::vector<std::vector<float>> schmidtQuasiNormFactors(expansionDegree + 1);
     schmidtQuasiNormFactors[0].resize(1);
     schmidtQuasiNormFactors[0][0] = 1.0f;
-    for (int32_t rowIndex = 1; rowIndex <= expansionDegree; rowIndex++) {
-        schmidtQuasiNormFactors[rowIndex].resize(rowIndex + 1);
-        schmidtQuasiNormFactors[rowIndex][0] =
-            schmidtQuasiNormFactors[rowIndex - 1][0] * (2 * rowIndex - 1) / static_cast<float>(rowIndex);
-        for (int32_t columnIndex = 1; columnIndex <= rowIndex; columnIndex++) {
-            schmidtQuasiNormFactors[rowIndex][columnIndex] = schmidtQuasiNormFactors[rowIndex][columnIndex - 1]
-                * static_cast<float>(sqrt((rowIndex - columnIndex + 1) * ((columnIndex == 1) ? 2 : 1)
-                / static_cast<float>(rowIndex + columnIndex)));
+    for (int32_t row = 1; row <= expansionDegree; row++) {
+        schmidtQuasiNormFactors[row].resize(row + 1);
+        schmidtQuasiNormFactors[row][0] =
+            schmidtQuasiNormFactors[row - 1][0] * (2 * row - 1) / static_cast<float>(row);
+        for (int32_t column = 1; column <= row; column++) {
+            schmidtQuasiNormFactors[row][column] = schmidtQuasiNormFactors[row][column - 1]
+                * static_cast<float>(sqrt((row - column + 1) * ((column == 1) ? 2 : 1)
+                / static_cast<float>(row + column)));
         }
     }
     return schmidtQuasiNormFactors;
 }
 
-void GeomagneticField::calculateGeomagneticComponent(double latDiffRad, int64_t timeMillis)
+void GeomagneticField::CalculateGeomagneticComponent(double latDiffRad, int64_t timeMillis)
 {
     HiLog::Info(LABEL, "%{public}s begin", __func__);
     float yearsSinceBase = (timeMillis - WMM_BASE_TIME) / (365.0f * 24.0f * 60.0f * 60.0f * 1000.0f);
     float inverseCosLatitude = DERIVATIVE_FACTOR / static_cast<float>(cos(geocentricLatitude));
-    getLongitudeTrigonometric();
+    GetLongitudeTrigonometric();
     float gcX = 0.0f;
     float gcY = 0.0f;
     float gcZ = 0.0f;
-    for (int32_t rowIndex = 1; rowIndex < GAUSSIAN_COEFFICIENT_DIMENSION; rowIndex++) {
-        for (int32_t columnIndex = 0; columnIndex <= rowIndex; columnIndex++) {
-            float g = GAUSS_COEFFICIENT_G[rowIndex][columnIndex] + yearsSinceBase
-                * DELTA_GAUSS_COEFFICIENT_G[rowIndex][columnIndex];
-            float h = GAUSS_COEFFICIENT_H[rowIndex][columnIndex] + yearsSinceBase
-                * DELTA_GAUSS_COEFFICIENT_H[rowIndex][columnIndex];
-            gcX += relativeRadiusPower[rowIndex + 2]
-                * (g * cosMLongitude[columnIndex] + h * sinMLongitude[columnIndex])
-                * polynomialsDerivative[rowIndex][columnIndex]
-                * schmidtQuasiNormalFactors[rowIndex][columnIndex];
-            gcY += relativeRadiusPower[rowIndex + 2] * columnIndex
-                * (g * sinMLongitude[columnIndex] - h * cosMLongitude[columnIndex])
-                * polynomials[rowIndex][columnIndex]
-                * schmidtQuasiNormalFactors[rowIndex][columnIndex]
+    for (int32_t row = 1; row < GAUSSIAN_COEFFICIENT_DIMENSION; row++) {
+        for (int32_t column = 0; column <= row; column++) {
+            float g = GAUSS_COEFFICIENT_G[row][column] + yearsSinceBase
+                * DELTA_GAUSS_COEFFICIENT_G[row][column];
+            float h = GAUSS_COEFFICIENT_H[row][column] + yearsSinceBase
+                * DELTA_GAUSS_COEFFICIENT_H[row][column];
+            gcX += relativeRadiusPower[row + 2]
+                * (g * cosMLongitude[column] + h * sinMLongitude[column])
+                * polynomialsDerivative[row][column]
+                * schmidtQuasiNormalFactors[row][column];
+            gcY += relativeRadiusPower[row + 2] * column
+                * (g * sinMLongitude[column] - h * cosMLongitude[column])
+                * polynomials[row][column]
+                * schmidtQuasiNormalFactors[row][column]
                 * inverseCosLatitude;
-            gcZ -= (rowIndex + 1) * relativeRadiusPower[rowIndex + 2]
-                * (g * cosMLongitude[columnIndex] + h * sinMLongitude[columnIndex])
-                * polynomials[rowIndex][columnIndex]
-                * schmidtQuasiNormalFactors[rowIndex][columnIndex];
+            gcZ -= (row + 1) * relativeRadiusPower[row + 2]
+                * (g * cosMLongitude[column] + h * sinMLongitude[column])
+                * polynomials[row][column]
+                * schmidtQuasiNormalFactors[row][column];
         }
         northComponent = static_cast<float>(gcX * cos(latDiffRad) + gcZ * sin(latDiffRad));
         eastComponent = gcY;
@@ -174,7 +174,7 @@ void GeomagneticField::calculateGeomagneticComponent(double latDiffRad, int64_t
     }
 }
 
-void GeomagneticField::getLongitudeTrigonometric()
+void GeomagneticField::GetLongitudeTrigonometric()
 {
     HiLog::Info(LABEL, "%{public}s begin", __func__);
     sinMLongitude[0] = 0.0f;
@@ -190,7 +190,7 @@ void GeomagneticField::getLongitudeTrigonometric()
     }
 }
 
-void GeomagneticField::getRelativeRadiusPower()
+void GeomagneticField::GetRelativeRadiusPower()
 {
     HiLog::Info(LABEL, "%{public}s begin", __func__);
     relativeRadiusPower[0] = 1.0f;
@@ -200,20 +200,20 @@ void GeomagneticField::getRelativeRadiusPower()
     }
 }
 
-void GeomagneticField::calibrateGeocentricCoordinates(float latitude, float longitude, float altitude)
+void GeomagneticField::CalibrateGeocentricCoordinates(float latitude, float longitude, float altitude)
 {
     HiLog::Info(LABEL, "%{public}s begin", __func__);
     float altitudeKm = altitude / CONVERSION_FACTOR;
     float a2 = EARTH_MAJOR_AXIS_RADIUS * EARTH_MAJOR_AXIS_RADIUS;
     float b2 = EARTH_MINOR_AXIS_RADIUS * EARTH_MINOR_AXIS_RADIUS;
-    double gdLatRad = toRadians(latitude);
+    double gdLatRad = ToRadians(latitude);
     float clat = static_cast<float>(cos(gdLatRad));
     float slat = static_cast<float>(sin(gdLatRad));
     float tlat = slat / clat;
     float latRad = static_cast<float>(sqrt(a2 * clat * clat + b2 * slat * slat));
     geocentricLatitude = static_cast<float>(atan(tlat * (latRad * altitudeKm + b2)
         / (latRad * altitudeKm + a2)));
-    geocentricLongitude = static_cast<float>(toRadians(longitude));
+    geocentricLongitude = static_cast<float>(ToRadians(longitude));
 
     float radSq = altitudeKm * altitudeKm + 2 * altitudeKm
         * latRad + (a2 * a2 * clat * clat + b2 * b2 * slat * slat)
@@ -221,7 +221,7 @@ void GeomagneticField::calibrateGeocentricCoordinates(float latitude, float long
     geocentricRadius = static_cast<float>(sqrt(radSq));
 }
 
-void GeomagneticField::initLegendreTable(int32_t expansionDegree, float thetaRad)
+void GeomagneticField::InitLegendreTable(int32_t expansionDegree, float thetaRad)
 {
     HiLog::Info(LABEL, "%{public}s begin", __func__);
     polynomials[0].resize(1);
@@ -230,78 +230,78 @@ void GeomagneticField::initLegendreTable(int32_t expansionDegree, float thetaRad
     polynomialsDerivative[0][0] = 0.0f;
     float cosValue = static_cast<float>(cos(thetaRad));
     float sinValue = static_cast<float>(sin(thetaRad));
-    for (int32_t rowIndex = 1; rowIndex <= expansionDegree; rowIndex++) {
-        polynomials[rowIndex].resize(rowIndex + 1);
-        polynomialsDerivative[rowIndex].resize(rowIndex + 1);
-        for (int32_t columnIndex = 0; columnIndex <= rowIndex; columnIndex++) {
-            if (rowIndex == columnIndex) {
-                polynomials[rowIndex][columnIndex] = sinValue * polynomials[rowIndex - 1][columnIndex - 1];
-                polynomialsDerivative[rowIndex][columnIndex] = cosValue * polynomials[rowIndex - 1][columnIndex - 1]
-                    + sinValue * polynomialsDerivative[rowIndex - 1][columnIndex - 1];
-            } else if (rowIndex == 1 || columnIndex == rowIndex - 1) {
-                polynomials[rowIndex][columnIndex] = cosValue * polynomials[rowIndex - 1][columnIndex];
-                polynomialsDerivative[rowIndex][columnIndex] = -sinValue * polynomials[rowIndex - 1][columnIndex]
-                    + cosValue * polynomialsDerivative[rowIndex - 1][columnIndex];
+    for (int32_t row = 1; row <= expansionDegree; row++) {
+        polynomials[row].resize(row + 1);
+        polynomialsDerivative[row].resize(row + 1);
+        for (int32_t column = 0; column <= row; column++) {
+            if (row == column) {
+                polynomials[row][column] = sinValue * polynomials[row - 1][column - 1];
+                polynomialsDerivative[row][column] = cosValue * polynomials[row - 1][column - 1]
+                    + sinValue * polynomialsDerivative[row - 1][column - 1];
+            } else if (row == 1 || column == row - 1) {
+                polynomials[row][column] = cosValue * polynomials[row - 1][column];
+                polynomialsDerivative[row][column] = -sinValue * polynomials[row - 1][column]
+                    + cosValue * polynomialsDerivative[row - 1][column];
             } else {
-                float k = ((rowIndex - 1) * (rowIndex - 1) - columnIndex * columnIndex)
-                    / static_cast<float>((2 * rowIndex - 1) * (2 * rowIndex - 3));
-                polynomials[rowIndex][columnIndex] = cosValue * polynomials[rowIndex - 1][columnIndex]
-                    - k * polynomials[rowIndex - 2][columnIndex];
-                polynomialsDerivative[rowIndex][columnIndex] = -sinValue * polynomials[rowIndex - 1][columnIndex]
-                    + cosValue * polynomialsDerivative[rowIndex - 1][columnIndex]
-                    - k * polynomialsDerivative[rowIndex - 2][columnIndex];
+                float k = ((row - 1) * (row - 1) - column * column)
+                    / static_cast<float>((2 * row - 1) * (2 * row - 3));
+                polynomials[row][column] = cosValue * polynomials[row - 1][column]
+                    - k * polynomials[row - 2][column];
+                polynomialsDerivative[row][column] = -sinValue * polynomials[row - 1][column]
+                    + cosValue * polynomialsDerivative[row - 1][column]
+                    - k * polynomialsDerivative[row - 2][column];
             }
         }
     }
 }
 
-float GeomagneticField::obtainX()
+float GeomagneticField::ObtainX()
 {
     HiLog::Info(LABEL, "%{public}s begin", __func__);
     return northComponent;
 }
 
-float GeomagneticField::obtainY()
+float GeomagneticField::ObtainY()
 {
     HiLog::Info(LABEL, "%{public}s begin", __func__);
     return eastComponent;
 }
 
-float GeomagneticField::obtainZ()
+float GeomagneticField::ObtainZ()
 {
     HiLog::Info(LABEL, "%{public}s begin", __func__);
     return downComponent;
 }
 
-float GeomagneticField::obtainGeomagneticDip()
+float GeomagneticField::ObtainGeomagneticDip()
 {
-    return static_cast<float>(toDegrees(atan2(downComponent, obtainLevelIntensity())));
+    return static_cast<float>(ToDegrees(atan2(downComponent, ObtainLevelIntensity())));
 }
 
-double GeomagneticField::toDegrees(double angrad)
+double GeomagneticField::ToDegrees(double angrad)
 {
     return angrad * 180.0 / M_PI;
 }
 
-double GeomagneticField::toRadians(double angdeg)
+double GeomagneticField::ToRadians(double angdeg)
 {
     return angdeg / 180.0 * M_PI;
 }
 
-float GeomagneticField::obtainDeflectionAngle()
+float GeomagneticField::ObtainDeflectionAngle()
 {
     HiLog::Info(LABEL, "%{public}s begin", __func__);
-    return static_cast<float>(toDegrees(atan2(eastComponent, northComponent)));
+    return static_cast<float>(ToDegrees(atan2(eastComponent, northComponent)));
 }
 
-float GeomagneticField::obtainLevelIntensity()
+float GeomagneticField::ObtainLevelIntensity()
 {
     HiLog::Info(LABEL, "%{public}s begin", __func__);
     float horizontalIntensity = hypot(northComponent, eastComponent);
     return horizontalIntensity;
 }
 
-float GeomagneticField::obtainTotalIntensity()
+float GeomagneticField::ObtainTotalIntensity()
 {
     HiLog::Info(LABEL, "%{public}s begin", __func__);
     float sumOfSquares = northComponent * northComponent + eastComponent * eastComponent
diff --git a/interfaces/plugin/src/sensor_js.cpp b/interfaces/plugin/src/sensor_js.cpp
index d70df4a5d225650e053a0c88d7f7be22a3a90779..263b131d18902a664314a025c2079ca2533b9b30 100644
--- a/interfaces/plugin/src/sensor_js.cpp
+++ b/interfaces/plugin/src/sensor_js.cpp
@@ -46,9 +46,8 @@ static std::map<int32_t, std::vector<struct AsyncCallbackInfo*>> g_onCallbackInf
 
 static void DataCallbackImpl(SensorEvent *event)
 {
-    HiLog::Info(LABEL, "%{public}s in", __func__);
     if (event == nullptr) {
-        HiLog::Error(LABEL, "%{public}s event is null!", __func__);
+        HiLog::Error(LABEL, "%{public}s event is null", __func__);
         return;
     }
     int32_t sensorTypeId = event->sensorTypeId;
@@ -89,7 +88,6 @@ static void DataCallbackImpl(SensorEvent *event)
         UnsubscribeSensor(sensorTypeId);
     }
     g_onceCallbackInfos.erase(sensorTypeId);
-    HiLog::Info(LABEL, "%{public}s end", __func__);
 }
 
 static const SensorUser user = {
@@ -226,7 +224,7 @@ static napi_value On(napi_env env, napi_callback_info info)
     if (argc == 3) {
         napi_value value = NapiGetNamedProperty(args[2], "interval", env);
         if (!IsMatchType(env, value, napi_number)) {
-            HiLog::Error(LABEL, "%{public}s argument should be napi_number type!", __func__);
+            HiLog::Error(LABEL, "%{public}s argument should be napi_number type", __func__);
             return nullptr;
         }
         interval = GetCppInt64(value, env);
@@ -258,7 +256,11 @@ static uint32_t RemoveCallback(napi_env env, int32_t sensorTypeId, napi_value ca
 {
     std::vector<struct AsyncCallbackInfo*> callbackInfos = g_onCallbackInfos[sensorTypeId];
     std::vector<struct AsyncCallbackInfo*>::iterator iter;
-    for (iter = callbackInfos.begin(); iter != callbackInfos.end(); iter++) {
+    for (iter = callbackInfos.begin(); iter != callbackInfos.end();) {
+        if (*iter == nullptr || (*iter)->callback[0] == nullptr) {
+            HiLog::Error(LABEL, "%{public}s arg is null", __func__);
+            continue;
+        }
         napi_value sensorCallback = nullptr;
         napi_get_reference_value(env, (*iter)->callback[0], &sensorCallback);
         if (IsNapiValueSame(env, callback, sensorCallback)) {
@@ -266,11 +268,13 @@ static uint32_t RemoveCallback(napi_env env, int32_t sensorTypeId, napi_value ca
             (*iter)->callback[0] = nullptr;
             delete *iter;
             *iter = nullptr;
-            callbackInfos.erase(iter);
+            callbackInfos.erase(iter++);
             if (callbackInfos.empty()) {
                 g_onCallbackInfos.erase(sensorTypeId);
                 return 0;
             }
+        } else {
+            ++iter;
         }
     }
     g_onCallbackInfos[sensorTypeId] = callbackInfos;
@@ -285,7 +289,7 @@ static napi_value Off(napi_env env, napi_callback_info info)
     napi_value thisVar = nullptr;
     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, NULL));
     if (argc < 1 || argc > 2 || !IsMatchType(env, args[0], napi_number)) {
-        HiLog::Error(LABEL, "%{public}s Invalid input.", __func__);
+        HiLog::Error(LABEL, "%{public}s Invalid input", __func__);
         return nullptr;
     }
     int32_t sensorTypeId = GetCppInt32(args[0], env);
@@ -316,11 +320,11 @@ static napi_value GetGeomagneticField(napi_env env, napi_callback_info info)
     napi_value thisVar = nullptr;
     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr));
     if (argc < 2 || argc > 3) {
-        HiLog::Error(LABEL, "%{public}s the number of input parameters does not match.", __func__);
+        HiLog::Error(LABEL, "%{public}s the number of input parameters does not match", __func__);
         return nullptr;
     }
     if (!IsMatchType(env, args[0], napi_object) || !IsMatchType(env, args[1], napi_number)) {
-        HiLog::Error(LABEL, "%{public}s argument is invalid.", __func__);
+        HiLog::Error(LABEL, "%{public}s argument is invalid", __func__);
         return nullptr;
     }
     napi_value napiLatitude = NapiGetNamedProperty(args[0], "latitude", env);
@@ -343,13 +347,13 @@ static napi_value GetGeomagneticField(napi_env env, napi_callback_info info)
         .type = GET_GEOMAGNETIC_FIELD,
     };
     asyncCallbackInfo->data.geomagneticData = {
-        .x = geomagneticField.obtainX(),
-        .y = geomagneticField.obtainY(),
-        .z = geomagneticField.obtainZ(),
-        .geomagneticDip = geomagneticField.obtainGeomagneticDip(),
-        .deflectionAngle = geomagneticField.obtainDeflectionAngle(),
-        .levelIntensity = geomagneticField.obtainLevelIntensity(),
-        .totalIntensity = geomagneticField.obtainTotalIntensity(),
+        .x = geomagneticField.ObtainX(),
+        .y = geomagneticField.ObtainY(),
+        .z = geomagneticField.ObtainZ(),
+        .geomagneticDip = geomagneticField.ObtainGeomagneticDip(),
+        .deflectionAngle = geomagneticField.ObtainDeflectionAngle(),
+        .levelIntensity = geomagneticField.ObtainLevelIntensity(),
+        .totalIntensity = geomagneticField.ObtainTotalIntensity(),
     };
     if (argc == 2) {
         napi_deferred deferred = nullptr;
@@ -384,7 +388,7 @@ static napi_value TransformCoordinateSystem(napi_env env, napi_callback_info inf
     napi_value napiAxisX = NapiGetNamedProperty(args[1], "axisX", env);
     napi_value napiAxisY = NapiGetNamedProperty(args[1], "axisY", env);
     if ((!IsMatchType(env, napiAxisX, napi_number)) || (!IsMatchType(env, napiAxisY, napi_number))) {
-        HiLog::Error(LABEL, "%{public}s argument should be napi_number type!", __func__);
+        HiLog::Error(LABEL, "%{public}s argument should be napi_number type", __func__);
         return nullptr;
     }
     int32_t axisX = GetCppInt32(napiAxisX, env);
@@ -418,7 +422,7 @@ static napi_value TransformCoordinateSystem(napi_env env, napi_callback_info inf
         return promise;
     }
     if (!IsMatchType(env, args[2], napi_function)) {
-        HiLog::Error(LABEL, "%{public}s argument should be napi_function type!", __func__);
+        HiLog::Error(LABEL, "%{public}s argument should be napi_function type", __func__);
         delete asyncCallbackInfo;
         asyncCallbackInfo = nullptr;
         return nullptr;
@@ -517,7 +521,7 @@ static napi_value GetDirection(napi_env env, napi_callback_info info)
         return promise;
     }
     if (!IsMatchType(env, args[1], napi_function)) {
-        HiLog::Error(LABEL, "%{public}s argument should be napi_function type!", __func__);
+        HiLog::Error(LABEL, "%{public}s argument should be napi_function type", __func__);
         napi_value result;
         napi_get_undefined(env, &result);
         delete asyncCallbackInfo;
@@ -536,7 +540,7 @@ static napi_value CreateQuaternion(napi_env env, napi_callback_info info)
     napi_value thisVar = nullptr;
     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr));
     if (argc < 1 || argc > 2 || !IsMatchArrayType(env, args[0])) {
-        HiLog::Error(LABEL, "%{public}s argument error!", __func__);
+        HiLog::Error(LABEL, "%{public}s argument error", __func__);
         return nullptr;
     }
     AsyncCallbackInfo *asyncCallbackInfo = new AsyncCallbackInfo {
@@ -568,7 +572,7 @@ static napi_value CreateQuaternion(napi_env env, napi_callback_info info)
         return promise;
     }
     if (!IsMatchType(env, args[1], napi_function)) {
-        HiLog::Error(LABEL, "%{public}s argument should be function!", __func__);
+        HiLog::Error(LABEL, "%{public}s argument should be function", __func__);
         delete asyncCallbackInfo;
         asyncCallbackInfo = nullptr;
         return nullptr;
@@ -586,7 +590,7 @@ static napi_value GetAltitude(napi_env env, napi_callback_info info)
     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr));
     if (argc < 2 || argc > 3 || !IsMatchType(env, args[0], napi_number)
         || !IsMatchType(env, args[1], napi_number)) {
-        HiLog::Error(LABEL, "%{public}s Invalid input.", __func__);
+        HiLog::Error(LABEL, "%{public}s Invalid input", __func__);
         return nullptr;
     }
     AsyncCallbackInfo *asyncCallbackInfo = new AsyncCallbackInfo {
@@ -633,7 +637,7 @@ static napi_value GetGeomagneticDip(napi_env env, napi_callback_info info)
     napi_value thisVar = nullptr;
     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr));
     if (argc < 1 || argc > 2 || !IsMatchArrayType(env, args[0])) {
-        HiLog::Error(LABEL, "%{public}s Invalid input.", __func__);
+        HiLog::Error(LABEL, "%{public}s Invalid input", __func__);
         return nullptr;
     }
     AsyncCallbackInfo *asyncCallbackInfo = new AsyncCallbackInfo {
@@ -662,7 +666,7 @@ static napi_value GetGeomagneticDip(napi_env env, napi_callback_info info)
         return promise;
     }
     if (!IsMatchType(env, args[1], napi_function)) {
-        HiLog::Error(LABEL, "%{public}s argument should be function!", __func__);
+        HiLog::Error(LABEL, "%{public}s argument should be function", __func__);
         delete asyncCallbackInfo;
         asyncCallbackInfo = nullptr;
         return nullptr;
@@ -847,7 +851,7 @@ static napi_value GetSingleSensor(napi_env env, napi_callback_info info)
         return promise;
     }
     if (!IsMatchType(env, args[1], napi_function)) {
-        HiLog::Error(LABEL, "%{public}s argument should be napi_function type!", __func__);
+        HiLog::Error(LABEL, "%{public}s argument should be napi_function type", __func__);
         delete asyncCallbackInfo;
         asyncCallbackInfo = nullptr;
         return nullptr;