diff --git a/native/src/correction.cpp b/native/src/correction.cpp
index d5bfed0..5d3bd71 100644
--- a/native/src/correction.cpp
+++ b/native/src/correction.cpp
@@ -113,6 +113,9 @@
     mInputIndex = mCorrectionStates[outputIndex].mInputIndex;
     mNeedsToTraverseAllNodes = mCorrectionStates[outputIndex].mNeedsToTraverseAllNodes;
 
+    mEquivalentCharStrongCount = mCorrectionStates[outputIndex].mEquivalentCharStrongCount;
+    mEquivalentCharNormalCount = mCorrectionStates[outputIndex].mEquivalentCharNormalCount;
+    mEquivalentCharWeakCount = mCorrectionStates[outputIndex].mEquivalentCharWeakCount;
     mProximityCount = mCorrectionStates[outputIndex].mProximityCount;
     mTransposedCount = mCorrectionStates[outputIndex].mTransposedCount;
     mExcessiveCount = mCorrectionStates[outputIndex].mExcessiveCount;
@@ -167,6 +170,9 @@
     mCorrectionStates[mOutputIndex].mInputIndex = mInputIndex;
     mCorrectionStates[mOutputIndex].mNeedsToTraverseAllNodes = mNeedsToTraverseAllNodes;
 
+    mCorrectionStates[mOutputIndex].mEquivalentCharStrongCount = mEquivalentCharStrongCount;
+    mCorrectionStates[mOutputIndex].mEquivalentCharNormalCount = mEquivalentCharNormalCount;
+    mCorrectionStates[mOutputIndex].mEquivalentCharWeakCount = mEquivalentCharWeakCount;
     mCorrectionStates[mOutputIndex].mProximityCount = mProximityCount;
     mCorrectionStates[mOutputIndex].mTransposedCount = mTransposedCount;
     mCorrectionStates[mOutputIndex].mExcessiveCount = mExcessiveCount;
@@ -208,6 +214,12 @@
     }
 }
 
+inline bool isEquivalentChar(ProximityInfo::ProximityType type) {
+    // 'type ProximityInfo::EQUIVALENT_CHAR_WEAK' means that
+    // type == ..._WEAK or type == ..._NORMAL or type == ..._STRONG.
+    return type <= ProximityInfo::EQUIVALENT_CHAR_WEAK;
+}
+
 Correction::CorrectionType Correction::processCharAndCalcState(
         const int32_t c, const bool isTerminal) {
     const int correctionCount = (mSkippedCount + mExcessiveCount + mTransposedCount);
@@ -219,8 +231,9 @@
         bool incremented = false;
         if (mLastCharExceeded && mInputIndex == mInputLength - 1) {
             // TODO: Do not check the proximity if EditDistance exceeds the threshold
-            const int matchId = mProximityInfo->getMatchedProximityId(mInputIndex, c, true);
-            if (matchId == ProximityInfo::SAME_OR_ACCENTED_OR_CAPITALIZED_CHAR) {
+            const ProximityInfo::ProximityType matchId =
+                    mProximityInfo->getMatchedProximityId(mInputIndex, c, true);
+            if (isEquivalentChar(matchId)) {
                 mLastCharExceeded = false;
                 --mExcessiveCount;
             } else if (matchId == ProximityInfo::NEAR_PROXIMITY_CHAR) {
@@ -264,8 +277,7 @@
 
     bool secondTransposing = false;
     if (mTransposedCount % 2 == 1) {
-        if (mProximityInfo->getMatchedProximityId(mInputIndex - 1, c, false)
-                == ProximityInfo::SAME_OR_ACCENTED_OR_CAPITALIZED_CHAR) {
+        if (isEquivalentChar(mProximityInfo->getMatchedProximityId(mInputIndex - 1, c, false))) {
             ++mTransposedCount;
             secondTransposing = true;
         } else if (mCorrectionStates[mOutputIndex].mExceeding) {
@@ -286,8 +298,8 @@
 
     // TODO: Change the limit if we'll allow two or more proximity chars with corrections
     const bool checkProximityChars = noCorrectionsHappenedSoFar ||  mProximityCount == 0;
-    const int matchedProximityCharId = secondTransposing
-            ? ProximityInfo::SAME_OR_ACCENTED_OR_CAPITALIZED_CHAR
+    const ProximityInfo::ProximityType matchedProximityCharId = secondTransposing
+            ? ProximityInfo::EQUIVALENT_CHAR_NORMAL
             : mProximityInfo->getMatchedProximityId(mInputIndex, c, checkProximityChars);
 
     if (ProximityInfo::UNRELATED_CHAR == matchedProximityCharId) {
@@ -297,19 +309,18 @@
         // here refers to the previous state.
         if (canTryCorrection && mCorrectionStates[mOutputIndex].mProximityMatching
                 && mCorrectionStates[mOutputIndex].mExceeding
-                && mProximityInfo->getMatchedProximityId(mInputIndex, mWord[mOutputIndex], false)
-                        == ProximityInfo::SAME_OR_ACCENTED_OR_CAPITALIZED_CHAR) {
+                && isEquivalentChar(mProximityInfo->getMatchedProximityId(
+                        mInputIndex, mWord[mOutputIndex], false))) {
             // Conversion p->e
             ++mExcessiveCount;
             --mProximityCount;
         } else if (mInputIndex < mInputLength - 1 && mOutputIndex > 0 && mTransposedCount > 0
                 && !mCorrectionStates[mOutputIndex].mTransposing
                 && mCorrectionStates[mOutputIndex - 1].mTransposing
-                && mProximityInfo->getMatchedProximityId(
-                        mInputIndex, mWord[mOutputIndex - 1], false)
-                                == ProximityInfo::SAME_OR_ACCENTED_OR_CAPITALIZED_CHAR
-                && mProximityInfo->getMatchedProximityId(mInputIndex + 1, c, false)
-                        == ProximityInfo::SAME_OR_ACCENTED_OR_CAPITALIZED_CHAR) {
+                && isEquivalentChar(mProximityInfo->getMatchedProximityId(
+                        mInputIndex, mWord[mOutputIndex - 1], false))
+                && isEquivalentChar(
+                        mProximityInfo->getMatchedProximityId(mInputIndex + 1, c, false))) {
             // Conversion t->e
             // Example:
             // occaisional -> occa   sional
@@ -320,8 +331,8 @@
         } else if (mOutputIndex > 0 && mInputIndex > 0 && mTransposedCount > 0
                 && !mCorrectionStates[mOutputIndex].mTransposing
                 && mCorrectionStates[mOutputIndex - 1].mTransposing
-                && mProximityInfo->getMatchedProximityId(mInputIndex - 1, c, false)
-                        == ProximityInfo::SAME_OR_ACCENTED_OR_CAPITALIZED_CHAR) {
+                && isEquivalentChar(
+                        mProximityInfo->getMatchedProximityId(mInputIndex - 1, c, false))) {
             // Conversion t->s
             // Example:
             // chcolate -> chocolate
@@ -332,8 +343,8 @@
         } else if (canTryCorrection && mInputIndex > 0
                 && mCorrectionStates[mOutputIndex].mProximityMatching
                 && mCorrectionStates[mOutputIndex].mSkipping
-                && mProximityInfo->getMatchedProximityId(mInputIndex - 1, c, false)
-                        == ProximityInfo::SAME_OR_ACCENTED_OR_CAPITALIZED_CHAR) {
+                && isEquivalentChar(
+                        mProximityInfo->getMatchedProximityId(mInputIndex - 1, c, false))) {
             // Conversion p->s
             // Note: This logic tries saving cases like contrst --> contrast -- "a" is one of
             // proximity chars of "s", but it should rather be handled as a skipped char.
@@ -341,8 +352,8 @@
             --mProximityCount;
             return processSkipChar(c, isTerminal, false);
         } else if ((mExceeding || mTransposing) && mInputIndex - 1 < mInputLength
-                && mProximityInfo->getMatchedProximityId(mInputIndex + 1, c, false)
-                        == ProximityInfo::SAME_OR_ACCENTED_OR_CAPITALIZED_CHAR) {
+                && isEquivalentChar(
+                        mProximityInfo->getMatchedProximityId(mInputIndex + 1, c, false))) {
             // 1.2. Excessive or transpose correction
             if (mTransposing) {
                 ++mTransposedCount;
@@ -362,14 +373,28 @@
             }
             return UNRELATED;
         }
-    } else if (secondTransposing
-            || ProximityInfo::SAME_OR_ACCENTED_OR_CAPITALIZED_CHAR == matchedProximityCharId) {
+    } else if (secondTransposing) {
         // If inputIndex is greater than mInputLength, that means there is no
         // proximity chars. So, we don't need to check proximity.
         mMatching = true;
+    } else if (isEquivalentChar(matchedProximityCharId)) {
+        mMatching = true;
+        switch (matchedProximityCharId) {
+        case ProximityInfo::EQUIVALENT_CHAR_STRONG:
+            ++mEquivalentCharStrongCount;
+            break;
+        case ProximityInfo::EQUIVALENT_CHAR_NORMAL:
+            ++mEquivalentCharNormalCount;
+            break;
+        case ProximityInfo::EQUIVALENT_CHAR_WEAK:
+            ++mEquivalentCharWeakCount;
+            break;
+        default:
+            assert(false);
+        }
     } else if (ProximityInfo::NEAR_PROXIMITY_CHAR == matchedProximityCharId) {
         mProximityMatching = true;
-        incrementProximityCount();
+        ++mProximityCount;
     }
 
     mWord[mOutputIndex] = c;
diff --git a/native/src/correction.h b/native/src/correction.h
index 41130ad..7d73dfa 100644
--- a/native/src/correction.h
+++ b/native/src/correction.h
@@ -102,11 +102,6 @@
     inline CorrectionType processSkipChar(
             const int32_t c, const bool isTerminal, const bool inputIndexIncremented);
 
-    // TODO: remove
-    inline void incrementProximityCount() {
-        ++mProximityCount;
-    }
-
     const int TYPED_LETTER_MULTIPLIER;
     const int FULL_WORD_MULTIPLIER;
     const ProximityInfo *mProximityInfo;
@@ -130,6 +125,9 @@
     int mOutputIndex;
     int mInputIndex;
 
+    int mEquivalentCharStrongCount;
+    int mEquivalentCharNormalCount;
+    int mEquivalentCharWeakCount;
     int mProximityCount;
     int mExcessiveCount;
     int mTransposedCount;
diff --git a/native/src/correction_state.h b/native/src/correction_state.h
index 93f8a8a..a8ee82a 100644
--- a/native/src/correction_state.h
+++ b/native/src/correction_state.h
@@ -29,6 +29,9 @@
     uint16_t mChildCount;
     uint8_t mInputIndex;
 
+    uint8_t mEquivalentCharStrongCount;
+    uint8_t mEquivalentCharNormalCount;
+    uint8_t mEquivalentCharWeakCount;
     uint8_t mProximityCount;
     uint8_t mTransposedCount;
     uint8_t mExcessiveCount;
@@ -63,7 +66,9 @@
     state->mExcessivePos = -1;
     state->mSkipPos = -1;
 
-
+    state->mEquivalentCharStrongCount = 0;
+    state->mEquivalentCharNormalCount = 0;
+    state->mEquivalentCharWeakCount = 0;
     state->mProximityCount = 0;
     state->mTransposedCount = 0;
     state->mExcessiveCount = 0;
diff --git a/native/src/defines.h b/native/src/defines.h
index 55469a7..6c619d1 100644
--- a/native/src/defines.h
+++ b/native/src/defines.h
@@ -165,6 +165,8 @@
 
 #define KEYCODE_SPACE ' '
 
+#define CALIBRATE_SCORE_BY_TOUCH_COORDINATES false
+
 #define SUGGEST_WORDS_WITH_MISSING_CHARACTER true
 #define SUGGEST_WORDS_WITH_MISSING_SPACE_CHARACTER true
 #define SUGGEST_WORDS_WITH_EXCESSIVE_CHARACTER true
@@ -204,4 +206,7 @@
 #define min(a,b) ((a)<(b)?(a):(b))
 #define max(a,b) ((a)>(b)?(a):(b))
 
+// The ratio of neutral area radius to sweet spot radius.
+#define NEUTRAL_AREA_RADIUS_RATIO 1.3f
+
 #endif // LATINIME_DEFINES_H
diff --git a/native/src/proximity_info.cpp b/native/src/proximity_info.cpp
index 4ff6e0a..081cb61 100644
--- a/native/src/proximity_info.cpp
+++ b/native/src/proximity_info.cpp
@@ -43,7 +43,8 @@
           KEYBOARD_HEIGHT(keyboardHeight), GRID_WIDTH(gridWidth), GRID_HEIGHT(gridHeight),
           CELL_WIDTH((keyboardWidth + gridWidth - 1) / gridWidth),
           CELL_HEIGHT((keyboardHeight + gridHeight - 1) / gridHeight),
-          KEY_COUNT(min(keyCount, MAX_KEY_COUNT_IN_A_KEYBOARD)) {
+          KEY_COUNT(min(keyCount, MAX_KEY_COUNT_IN_A_KEYBOARD)),
+          mInputXCoordinates(NULL), mInputYCoordinates(NULL) {
     const int len = GRID_WIDTH * GRID_HEIGHT * MAX_PROXIMITY_CHARS_SIZE;
     mProximityCharsArray = new uint32_t[len];
     if (DEBUG_PROXIMITY_INFO) {
@@ -103,8 +104,11 @@
 }
 
 // TODO: Calculate nearby codes here.
-void ProximityInfo::setInputParams(const int* inputCodes, const int inputLength) {
+void ProximityInfo::setInputParams(const int* inputCodes, const int inputLength,
+        const int* xCoordinates, const int* yCoordinates) {
     mInputCodes = inputCodes;
+    mInputXCoordinates = xCoordinates;
+    mInputYCoordinates = yCoordinates;
     mInputLength = inputLength;
     for (int i = 0; i < inputLength; ++i) {
         mPrimaryInputWord[i] = getPrimaryCharAt(i);
@@ -158,19 +162,37 @@
 ProximityInfo::ProximityType ProximityInfo::getMatchedProximityId(
         const int index, const unsigned short c, const bool checkProximityChars) const {
     const int *currentChars = getProximityCharsAt(index);
+    const int firstChar = currentChars[0];
     const unsigned short baseLowerC = Dictionary::toBaseLowerCase(c);
 
     // The first char in the array is what user typed. If it matches right away,
     // that means the user typed that same char for this pos.
-    if (currentChars[0] == baseLowerC || currentChars[0] == c)
-        return SAME_OR_ACCENTED_OR_CAPITALIZED_CHAR;
+    if (firstChar == baseLowerC || firstChar == c) {
+        if (CALIBRATE_SCORE_BY_TOUCH_COORDINATES) {
+            const SweetSpotType result = calculateSweetSpotType(index, baseLowerC);
+            switch (result) {
+            case UNKNOWN:
+                return EQUIVALENT_CHAR_NORMAL;
+            case IN_SWEET_SPOT:
+                return EQUIVALENT_CHAR_STRONG;
+            case IN_NEUTRAL_AREA:
+                return EQUIVALENT_CHAR_NORMAL;
+            case OUT_OF_NEUTRAL_AREA:
+                return EQUIVALENT_CHAR_WEAK;
+            default:
+                assert(false);
+            }
+        } else {
+            return EQUIVALENT_CHAR_NORMAL;
+        }
+    }
 
     if (!checkProximityChars) return UNRELATED_CHAR;
 
     // If the non-accented, lowercased version of that first character matches c,
     // then we have a non-accented version of the accented character the user
     // typed. Treat it as a close char.
-    if (Dictionary::toBaseLowerCase(currentChars[0]) == baseLowerC)
+    if (Dictionary::toBaseLowerCase(firstChar) == baseLowerC)
         return NEAR_PROXIMITY_CHAR;
 
     // Not an exact nor an accent-alike match: search the list of close keys
@@ -185,6 +207,38 @@
     return UNRELATED_CHAR;
 }
 
+inline float square(const float x) { return x * x; }
+
+ProximityInfo::SweetSpotType ProximityInfo::calculateSweetSpotType(
+        int index, unsigned short baseLowerC) const {
+    if (KEY_COUNT == 0 || !mInputXCoordinates || !mInputYCoordinates
+            || baseLowerC > MAX_CHAR_CODE) {
+        return UNKNOWN;
+    }
+    const int keyIndex = mCodeToKeyIndex[baseLowerC];
+    if (keyIndex < 0) {
+        return UNKNOWN;
+    }
+    const float sweetSpotRadius = mSweetSpotRadii[keyIndex];
+    if (sweetSpotRadius <= 0.0) {
+        return UNKNOWN;
+    }
+    const float sweetSpotCenterX = mSweetSpotCenterXs[keyIndex];
+    const float sweetSpotCenterY = mSweetSpotCenterXs[keyIndex];
+    const float inputX = (float)mInputXCoordinates[index];
+    const float inputY = (float)mInputYCoordinates[index];
+    const float squaredDistance =
+            square(inputX - sweetSpotCenterX) + square(inputY - sweetSpotCenterY);
+    const float squaredSweetSpotRadius = square(sweetSpotRadius);
+    if (squaredDistance <= squaredSweetSpotRadius) {
+        return IN_SWEET_SPOT;
+    }
+    if (squaredDistance <= square(NEUTRAL_AREA_RADIUS_RATIO) * squaredSweetSpotRadius) {
+        return IN_NEUTRAL_AREA;
+    }
+    return OUT_OF_NEUTRAL_AREA;
+}
+
 bool ProximityInfo::sameAsTyped(const unsigned short *word, int length) const {
     if (length != mInputLength) {
         return false;
diff --git a/native/src/proximity_info.h b/native/src/proximity_info.h
index b1e8236..a705d0c 100644
--- a/native/src/proximity_info.h
+++ b/native/src/proximity_info.h
@@ -27,10 +27,18 @@
 
 class ProximityInfo {
 public:
-    typedef enum {                             // Used as a return value for character comparison
-        SAME_OR_ACCENTED_OR_CAPITALIZED_CHAR,  // Same char, possibly with different case or accent
-        NEAR_PROXIMITY_CHAR,                   // It is a char located nearby on the keyboard
-        UNRELATED_CHAR                         // It is an unrelated char
+    // Used as a return value for character comparison
+    typedef enum {
+        // Same char, possibly with different case or accent, and in the sweet spot of the char
+        EQUIVALENT_CHAR_STRONG,
+        // Same char, possibly with different case or accent, and in the outer sweet spot
+        EQUIVALENT_CHAR_NORMAL,
+        // Same char, possibly with different case or accent, and in the hit box of the char
+        EQUIVALENT_CHAR_WEAK,
+        // It is a char located nearby on the keyboard
+        NEAR_PROXIMITY_CHAR,
+        // It is an unrelated char
+        UNRELATED_CHAR
     } ProximityType;
 
     ProximityInfo(const int maxProximityCharsSize, const int keyboardWidth,
@@ -41,7 +49,8 @@
             const float *sweetSpotCenterYs, const float *sweetSpotRadii);
     ~ProximityInfo();
     bool hasSpaceProximity(const int x, const int y) const;
-    void setInputParams(const int* inputCodes, const int inputLength);
+    void setInputParams(const int* inputCodes, const int inputLength,
+            const int *xCoordinates, const int *yCoordinates);
     const int* getProximityCharsAt(const int index) const;
     unsigned short getPrimaryCharAt(const int index) const;
     bool existsCharInProximityAt(const int index, const int c) const;
@@ -59,8 +68,20 @@
     // The upper limit of the char code in mCodeToKeyIndex
     static const int MAX_CHAR_CODE = 127;
 
+    typedef enum {
+        // cannot figure out the sweet spot type
+        UNKNOWN,
+        // touch position is out of neutral area of the given char
+        OUT_OF_NEUTRAL_AREA,
+        // touch position is in the neutral area of the given char
+        IN_NEUTRAL_AREA,
+        // touch position is in the sweet spot of the given char
+        IN_SWEET_SPOT
+    } SweetSpotType;
+
     int getStartIndexFromCoordinates(const int x, const int y) const;
     void initializeCodeToKeyIndex();
+    SweetSpotType calculateSweetSpotType(int index, unsigned short baseLowerC) const;
     const int MAX_PROXIMITY_CHARS_SIZE;
     const int KEYBOARD_WIDTH;
     const int KEYBOARD_HEIGHT;
@@ -70,6 +91,8 @@
     const int CELL_HEIGHT;
     const int KEY_COUNT;
     const int *mInputCodes;
+    const int *mInputXCoordinates;
+    const int *mInputYCoordinates;
     uint32_t *mProximityCharsArray;
     int32_t mKeyXCoordinates[MAX_KEY_COUNT_IN_A_KEYBOARD];
     int32_t mKeyYCoordinates[MAX_KEY_COUNT_IN_A_KEYBOARD];
diff --git a/native/src/unigram_dictionary.cpp b/native/src/unigram_dictionary.cpp
index 517dc84..cdd84aa 100644
--- a/native/src/unigram_dictionary.cpp
+++ b/native/src/unigram_dictionary.cpp
@@ -238,8 +238,8 @@
     PROF_END(6);
 }
 
-void UnigramDictionary::initSuggestions(ProximityInfo *proximityInfo, const int *xcoordinates,
-        const int *ycoordinates, const int *codes, const int codesSize,
+void UnigramDictionary::initSuggestions(ProximityInfo *proximityInfo, const int *xCoordinates,
+        const int *yCoordinates, const int *codes, const int codesSize,
         unsigned short *outWords, int *frequencies) {
     if (DEBUG_DICT) {
         LOGI("initSuggest");
@@ -247,7 +247,7 @@
     mFrequencies = frequencies;
     mOutputChars = outWords;
     mInputLength = codesSize;
-    proximityInfo->setInputParams(codes, codesSize);
+    proximityInfo->setInputParams(codes, codesSize, xCoordinates, yCoordinates);
     mProximityInfo = proximityInfo;
 }