diff options
Diffstat (limited to 'java/src/com/android/inputmethod/research/ResearchLogger.java')
| -rw-r--r-- | java/src/com/android/inputmethod/research/ResearchLogger.java | 340 |
1 files changed, 263 insertions, 77 deletions
diff --git a/java/src/com/android/inputmethod/research/ResearchLogger.java b/java/src/com/android/inputmethod/research/ResearchLogger.java index b1484e696..f4249a045 100644 --- a/java/src/com/android/inputmethod/research/ResearchLogger.java +++ b/java/src/com/android/inputmethod/research/ResearchLogger.java @@ -85,7 +85,7 @@ public class ResearchLogger implements SharedPreferences.OnSharedPreferenceChang private static final String TAG = ResearchLogger.class.getSimpleName(); private static final boolean DEBUG = false && ProductionFlag.IS_EXPERIMENTAL_DEBUG; // Whether all n-grams should be logged. true will disclose private info. - private static final boolean LOG_EVERYTHING = false + public static final boolean IS_LOGGING_EVERYTHING = false && ProductionFlag.IS_EXPERIMENTAL_DEBUG; // Whether the TextView contents are logged at the end of the session. true will disclose // private info. @@ -105,7 +105,7 @@ public class ResearchLogger implements SharedPreferences.OnSharedPreferenceChang private static final boolean IS_SHOWING_INDICATOR = true; // Change the default indicator to something very visible. Currently two red vertical bars on // either side of they keyboard. - private static final boolean IS_SHOWING_INDICATOR_CLEARLY = false || LOG_EVERYTHING; + private static final boolean IS_SHOWING_INDICATOR_CLEARLY = false || IS_LOGGING_EVERYTHING; public static final int FEEDBACK_WORD_BUFFER_SIZE = 5; // constants related to specific log points @@ -324,11 +324,22 @@ public class ResearchLogger implements SharedPreferences.OnSharedPreferenceChang sIsLogging = enableLogging; } + private static int sLogFileCounter = 0; + private File createLogFile(File filesDir) { final StringBuilder sb = new StringBuilder(); sb.append(FILENAME_PREFIX).append('-'); sb.append(mUUIDString).append('-'); - sb.append(TIMESTAMP_DATEFORMAT.format(new Date())); + sb.append(TIMESTAMP_DATEFORMAT.format(new Date())).append('-'); + // Sometimes logFiles are created within milliseconds of each other. Append a counter to + // separate these. + if (sLogFileCounter < Integer.MAX_VALUE) { + sLogFileCounter++; + } else { + // Wrap the counter, in the unlikely event of overflow. + sLogFileCounter = 0; + } + sb.append(sLogFileCounter); sb.append(FILENAME_SUFFIX); return new File(filesDir, sb.toString()); } @@ -374,12 +385,12 @@ public class ResearchLogger implements SharedPreferences.OnSharedPreferenceChang return; } if (mMainLogBuffer == null) { - mMainResearchLog = new ResearchLog(createLogFile(mFilesDir)); + mMainResearchLog = new ResearchLog(createLogFile(mFilesDir), mLatinIME); mMainLogBuffer = new MainLogBuffer(mMainResearchLog); mMainLogBuffer.setSuggest(mSuggest); } if (mFeedbackLogBuffer == null) { - mFeedbackLog = new ResearchLog(createLogFile(mFilesDir)); + mFeedbackLog = new ResearchLog(createLogFile(mFilesDir), mLatinIME); // LogBuffer is one more than FEEDBACK_WORD_BUFFER_SIZE, because it must also hold // the feedback LogUnit itself. mFeedbackLogBuffer = new FixedLogBuffer(FEEDBACK_WORD_BUFFER_SIZE + 1); @@ -390,11 +401,20 @@ public class ResearchLogger implements SharedPreferences.OnSharedPreferenceChang if (DEBUG) { Log.d(TAG, "stop called"); } + // Commit mCurrentLogUnit before closing. commitCurrentLogUnit(); if (mMainLogBuffer != null) { - publishLogBuffer(mMainLogBuffer, mMainResearchLog, - LOG_EVERYTHING /* isIncludingPrivateData */); + while (!mMainLogBuffer.isEmpty()) { + if ((mMainLogBuffer.isNGramSafe() || IS_LOGGING_EVERYTHING) && + mMainResearchLog != null) { + publishLogBuffer(mMainLogBuffer, mMainResearchLog, + true /* isIncludingPrivateData */); + mMainLogBuffer.resetWordCounter(); + } else { + mMainLogBuffer.shiftOutThroughFirstWord(); + } + } mMainResearchLog.close(null /* callback */); mMainLogBuffer = null; } @@ -590,7 +610,7 @@ public class ResearchLogger implements SharedPreferences.OnSharedPreferenceChang uploadNow(); } }); - mFeedbackLog = new ResearchLog(createLogFile(mFilesDir)); + mFeedbackLog = new ResearchLog(createLogFile(mFilesDir), mLatinIME); } public void uploadNow() { @@ -676,11 +696,17 @@ public class ResearchLogger implements SharedPreferences.OnSharedPreferenceChang /** * Buffer a research log event, flagging it as privacy-sensitive. */ - private synchronized void enqueueEvent(LogStatement logStatement, Object... values) { + private synchronized void enqueueEvent(final LogStatement logStatement, + final Object... values) { + enqueueEvent(mCurrentLogUnit, logStatement, values); + } + + private synchronized void enqueueEvent(final LogUnit logUnit, final LogStatement logStatement, + final Object... values) { assert values.length == logStatement.mKeys.length; - if (isAllowedToLog()) { + if (isAllowedToLog() && logUnit != null) { final long time = SystemClock.uptimeMillis(); - mCurrentLogUnit.addLogStatement(logStatement, time, values); + logUnit.addLogStatement(logStatement, time, values); } } @@ -695,17 +721,70 @@ public class ResearchLogger implements SharedPreferences.OnSharedPreferenceChang } if (!mCurrentLogUnit.isEmpty()) { if (mMainLogBuffer != null) { - mMainLogBuffer.shiftIn(mCurrentLogUnit); - if ((mMainLogBuffer.isSafeToLog() || LOG_EVERYTHING) && mMainResearchLog != null) { + if ((mMainLogBuffer.isNGramSafe() || IS_LOGGING_EVERYTHING) && + mMainLogBuffer.isNGramComplete() && + mMainResearchLog != null) { publishLogBuffer(mMainLogBuffer, mMainResearchLog, true /* isIncludingPrivateData */); mMainLogBuffer.resetWordCounter(); } + mMainLogBuffer.shiftIn(mCurrentLogUnit); } if (mFeedbackLogBuffer != null) { mFeedbackLogBuffer.shiftIn(mCurrentLogUnit); } mCurrentLogUnit = new LogUnit(); + } else { + if (DEBUG) { + Log.d(TAG, "Warning: tried to commit empty log unit."); + } + } + } + + private static final LogStatement LOGSTATEMENT_UNCOMMIT_CURRENT_LOGUNIT = + new LogStatement("UncommitCurrentLogUnit", false, false); + public void uncommitCurrentLogUnit(final String expectedWord, + final boolean dumpCurrentLogUnit) { + // The user has deleted this word and returned to the previous. Check that the word in the + // logUnit matches the expected word. If so, restore the last log unit committed to be the + // current logUnit. I.e., pull out the last LogUnit from all the LogBuffers, and make + // restore it to mCurrentLogUnit so the new edits are captured with the word. Optionally + // dump the contents of mCurrentLogUnit (useful if they contain deletions of the next word + // that should not be reported to protect user privacy) + // + // Note that we don't use mLastLogUnit here, because it only goes one word back and is only + // needed for reverts, which only happen one back. + if (mMainLogBuffer == null) { + return; + } + final LogUnit oldLogUnit = mMainLogBuffer.peekLastLogUnit(); + + // Check that expected word matches. + if (oldLogUnit != null) { + final String oldLogUnitWord = oldLogUnit.getWord(); + if (!oldLogUnitWord.equals(expectedWord)) { + return; + } + } + + // Uncommit, merging if necessary. + mMainLogBuffer.unshiftIn(); + if (oldLogUnit != null && !dumpCurrentLogUnit) { + oldLogUnit.append(mCurrentLogUnit); + mSavedDownEventTime = Long.MAX_VALUE; + } + if (oldLogUnit == null) { + mCurrentLogUnit = new LogUnit(); + } else { + mCurrentLogUnit = oldLogUnit; + } + if (mFeedbackLogBuffer != null) { + mFeedbackLogBuffer.unshiftIn(); + } + enqueueEvent(LOGSTATEMENT_UNCOMMIT_CURRENT_LOGUNIT); + if (DEBUG) { + Log.d(TAG, "uncommitCurrentLogUnit (dump=" + dumpCurrentLogUnit + ") back to " + + (mCurrentLogUnit.hasWord() ? ": '" + mCurrentLogUnit.getWord() + "'" : "")); } } @@ -721,12 +800,16 @@ public class ResearchLogger implements SharedPreferences.OnSharedPreferenceChang isIncludingPrivateData); researchLog.publish(openingLogUnit, true /* isIncludingPrivateData */); LogUnit logUnit; - while ((logUnit = logBuffer.shiftOut()) != null) { + int numWordsToPublish = MainLogBuffer.N_GRAM_SIZE; + while ((logUnit = logBuffer.shiftOut()) != null && numWordsToPublish > 0) { if (DEBUG) { Log.d(TAG, "publishLogBuffer: " + (logUnit.hasWord() ? logUnit.getWord() : "<wordless>")); } researchLog.publish(logUnit, isIncludingPrivateData); + if (logUnit.getWord() != null) { + numWordsToPublish--; + } } final LogUnit closingLogUnit = new LogUnit(); closingLogUnit.addLogStatement(LOGSTATEMENT_LOG_SEGMENT_CLOSING, @@ -751,24 +834,30 @@ public class ResearchLogger implements SharedPreferences.OnSharedPreferenceChang * After this operation completes, mCurrentLogUnit will hold any logStatements that happened * after maxTime. */ - private static final LogStatement LOGSTATEMENT_COMMIT_RECORD_SPLIT_WORDS = - new LogStatement("recordSplitWords", true, false); - /* package for test */ void commitCurrentLogUnitAsWord(final String word, final long maxTime) { + /* package for test */ void commitCurrentLogUnitAsWord(final String word, final long maxTime, + final boolean isBatchMode) { + if (word == null) { + return; + } final Dictionary dictionary = getDictionary(); - if (word != null && word.length() > 0 && hasLetters(word)) { + if (word.length() > 0 && hasLetters(word)) { mCurrentLogUnit.setWord(word); final boolean isDictionaryWord = dictionary != null && dictionary.isValidWord(word); mStatistics.recordWordEntered(isDictionaryWord); } final LogUnit newLogUnit = mCurrentLogUnit.splitByTime(maxTime); - enqueueCommitText(word); + enqueueCommitText(word, isBatchMode); commitCurrentLogUnit(); mCurrentLogUnit = newLogUnit; } - public void onWordFinished(final String word) { - commitCurrentLogUnitAsWord(word, mSavedDownEventTime); + private void setSavedDownEventTime(final long time) { + mSavedDownEventTime = time; + } + + public void onWordFinished(final String word, final boolean isBatchMode) { + commitCurrentLogUnitAsWord(word, mSavedDownEventTime, isBatchMode); mSavedDownEventTime = Long.MAX_VALUE; } @@ -863,7 +952,7 @@ public class ResearchLogger implements SharedPreferences.OnSharedPreferenceChang Integer.toHexString(editorInfo.inputType), Integer.toHexString(editorInfo.imeOptions), editorInfo.fieldId, Build.DISPLAY, Build.MODEL, prefs, versionCode, versionName, - OUTPUT_FORMAT_VERSION, LOG_EVERYTHING, + OUTPUT_FORMAT_VERSION, IS_LOGGING_EVERYTHING, ProductionFlag.IS_EXPERIMENTAL_DEBUG); } catch (NameNotFoundException e) { e.printStackTrace(); @@ -916,7 +1005,7 @@ public class ResearchLogger implements SharedPreferences.OnSharedPreferenceChang if (action == MotionEvent.ACTION_DOWN) { // Subtract 1 from eventTime so the down event is included in the later // LogUnit, not the earlier (the test is for inequality). - researchLogger.mSavedDownEventTime = eventTime - 1; + researchLogger.setSavedDownEventTime(eventTime - 1); } } } @@ -1060,9 +1149,9 @@ public class ResearchLogger implements SharedPreferences.OnSharedPreferenceChang * * SystemResponse: Raw text is added to the TextView. */ - public static void latinIME_onTextInput(final String text) { + public static void latinIME_onTextInput(final String text, final boolean isBatchMode) { final ResearchLogger researchLogger = getInstance(); - researchLogger.commitCurrentLogUnitAsWord(text, Long.MAX_VALUE); + researchLogger.commitCurrentLogUnitAsWord(text, Long.MAX_VALUE, isBatchMode); } /** @@ -1074,15 +1163,15 @@ public class ResearchLogger implements SharedPreferences.OnSharedPreferenceChang new LogStatement("LatinIMEPickSuggestionManually", true, false, "replacedWord", "index", "suggestion", "x", "y"); public static void latinIME_pickSuggestionManually(final String replacedWord, - final int index, final String suggestion) { + final int index, final String suggestion, final boolean isBatchMode) { final String scrubbedWord = scrubDigitsFromString(suggestion); final ResearchLogger researchLogger = getInstance(); researchLogger.enqueueEvent(LOGSTATEMENT_LATINIME_PICKSUGGESTIONMANUALLY, scrubDigitsFromString(replacedWord), index, suggestion == null ? null : scrubbedWord, Constants.SUGGESTION_STRIP_COORDINATE, Constants.SUGGESTION_STRIP_COORDINATE); - researchLogger.commitCurrentLogUnitAsWord(scrubbedWord, Long.MAX_VALUE); - researchLogger.mStatistics.recordManualSuggestion(); + researchLogger.commitCurrentLogUnitAsWord(scrubbedWord, Long.MAX_VALUE, isBatchMode); + researchLogger.mStatistics.recordManualSuggestion(SystemClock.uptimeMillis()); } /** @@ -1092,20 +1181,21 @@ public class ResearchLogger implements SharedPreferences.OnSharedPreferenceChang */ private static final LogStatement LOGSTATEMENT_LATINIME_PUNCTUATIONSUGGESTION = new LogStatement("LatinIMEPunctuationSuggestion", false, false, "index", "suggestion", - "x", "y"); - public static void latinIME_punctuationSuggestion(final int index, final String suggestion) { + "x", "y", "isPrediction"); + public static void latinIME_punctuationSuggestion(final int index, final String suggestion, + final boolean isBatchMode, final boolean isPrediction) { final ResearchLogger researchLogger = getInstance(); researchLogger.enqueueEvent(LOGSTATEMENT_LATINIME_PUNCTUATIONSUGGESTION, index, suggestion, - Constants.SUGGESTION_STRIP_COORDINATE, Constants.SUGGESTION_STRIP_COORDINATE); - researchLogger.commitCurrentLogUnitAsWord(suggestion, Long.MAX_VALUE); + Constants.SUGGESTION_STRIP_COORDINATE, Constants.SUGGESTION_STRIP_COORDINATE, + isPrediction); + researchLogger.commitCurrentLogUnitAsWord(suggestion, Long.MAX_VALUE, isBatchMode); } /** * Log a call to LatinIME.sendKeyCodePoint(). * - * SystemResponse: The IME is simulating a hardware keypress. This happens for numbers; other - * input typically goes through RichInputConnection.setComposingText() and - * RichInputConnection.commitText(). + * SystemResponse: The IME is inserting text into the TextView for numbers, fixed strings, or + * some other unusual mechanism. */ private static final LogStatement LOGSTATEMENT_LATINIME_SENDKEYCODEPOINT = new LogStatement("LatinIMESendKeyCodePoint", true, false, "code"); @@ -1119,17 +1209,45 @@ public class ResearchLogger implements SharedPreferences.OnSharedPreferenceChang } /** + * Log a call to LatinIME.promotePhantomSpace(). + * + * SystemResponse: The IME is inserting a real space in place of a phantom space. + */ + private static final LogStatement LOGSTATEMENT_LATINIME_PROMOTEPHANTOMSPACE = + new LogStatement("LatinIMEPromotPhantomSpace", false, false); + public static void latinIME_promotePhantomSpace() { + final ResearchLogger researchLogger = getInstance(); + final LogUnit logUnit; + if (researchLogger.mMainLogBuffer == null) { + logUnit = researchLogger.mCurrentLogUnit; + } else { + logUnit = researchLogger.mMainLogBuffer.peekLastLogUnit(); + } + researchLogger.enqueueEvent(logUnit, LOGSTATEMENT_LATINIME_PROMOTEPHANTOMSPACE); + } + + /** * Log a call to LatinIME.swapSwapperAndSpace(). * * SystemResponse: A symbol has been swapped with a space character. E.g. punctuation may swap * if a soft space is inserted after a word. */ private static final LogStatement LOGSTATEMENT_LATINIME_SWAPSWAPPERANDSPACE = - new LogStatement("LatinIMESwapSwapperAndSpace", false, false); - public static void latinIME_swapSwapperAndSpace(final String text) { + new LogStatement("LatinIMESwapSwapperAndSpace", false, false, "originalCharacters", + "charactersAfterSwap"); + public static void latinIME_swapSwapperAndSpace(final CharSequence originalCharacters, + final String charactersAfterSwap) { final ResearchLogger researchLogger = getInstance(); - researchLogger.commitCurrentLogUnitAsWord(text, Long.MAX_VALUE); - researchLogger.enqueueEvent(LOGSTATEMENT_LATINIME_SWAPSWAPPERANDSPACE); + final LogUnit logUnit; + if (researchLogger.mMainLogBuffer == null) { + logUnit = null; + } else { + logUnit = researchLogger.mMainLogBuffer.peekLastLogUnit(); + } + if (logUnit != null) { + researchLogger.enqueueEvent(logUnit, LOGSTATEMENT_LATINIME_SWAPSWAPPERANDSPACE, + originalCharacters, charactersAfterSwap); + } } /** @@ -1137,9 +1255,10 @@ public class ResearchLogger implements SharedPreferences.OnSharedPreferenceChang * * SystemResponse: Two spaces have been replaced by period space. */ - public static void latinIME_maybeDoubleSpacePeriod(final String text) { + public static void latinIME_maybeDoubleSpacePeriod(final String text, + final boolean isBatchMode) { final ResearchLogger researchLogger = getInstance(); - researchLogger.commitCurrentLogUnitAsWord(text, Long.MAX_VALUE); + researchLogger.commitCurrentLogUnitAsWord(text, Long.MAX_VALUE, isBatchMode); } /** @@ -1169,8 +1288,9 @@ public class ResearchLogger implements SharedPreferences.OnSharedPreferenceChang public static void mainKeyboardView_setKeyboard(final Keyboard keyboard) { final KeyboardId kid = keyboard.mId; final boolean isPasswordView = kid.passwordInput(); - getInstance().setIsPasswordView(isPasswordView); - getInstance().enqueueEvent(LOGSTATEMENT_MAINKEYBOARDVIEW_SETKEYBOARD, + final ResearchLogger researchLogger = getInstance(); + researchLogger.setIsPasswordView(isPasswordView); + researchLogger.enqueueEvent(LOGSTATEMENT_MAINKEYBOARDVIEW_SETKEYBOARD, KeyboardId.elementIdToName(kid.mElementId), kid.mLocale + ":" + kid.mSubtype.getExtraValueOf(KEYBOARD_LAYOUT_SET), kid.mOrientation, kid.mWidth, KeyboardId.modeName(kid.mMode), kid.imeAction(), @@ -1189,14 +1309,28 @@ public class ResearchLogger implements SharedPreferences.OnSharedPreferenceChang */ private static final LogStatement LOGSTATEMENT_LATINIME_REVERTCOMMIT = new LogStatement("LatinIMERevertCommit", true, false, "committedWord", - "originallyTypedWord"); + "originallyTypedWord", "separatorString"); public static void latinIME_revertCommit(final String committedWord, - final String originallyTypedWord) { + final String originallyTypedWord, final boolean isBatchMode, + final String separatorString) { final ResearchLogger researchLogger = getInstance(); - researchLogger.enqueueEvent(LOGSTATEMENT_LATINIME_REVERTCOMMIT, committedWord, - originallyTypedWord); - researchLogger.mStatistics.recordRevertCommit(); - researchLogger.commitCurrentLogUnitAsWord(originallyTypedWord, Long.MAX_VALUE); + // TODO: Verify that mCurrentLogUnit has been restored and contains the reverted word. + final LogUnit logUnit; + if (researchLogger.mMainLogBuffer == null) { + logUnit = null; + } else { + logUnit = researchLogger.mMainLogBuffer.peekLastLogUnit(); + } + if (originallyTypedWord.length() > 0 && hasLetters(originallyTypedWord)) { + if (logUnit != null) { + logUnit.setWord(originallyTypedWord); + } + } + researchLogger.enqueueEvent(logUnit != null ? logUnit : researchLogger.mCurrentLogUnit, + LOGSTATEMENT_LATINIME_REVERTCOMMIT, committedWord, originallyTypedWord, + separatorString); + researchLogger.mStatistics.recordRevertCommit(SystemClock.uptimeMillis()); + researchLogger.commitCurrentLogUnitAsWord(originallyTypedWord, Long.MAX_VALUE, isBatchMode); } /** @@ -1295,9 +1429,10 @@ public class ResearchLogger implements SharedPreferences.OnSharedPreferenceChang * * SystemResponse: The IME has reverted ". ", which had previously replaced two typed spaces. */ - public static void richInputConnection_revertDoubleSpacePeriod(final String doubleSpace) { - final ResearchLogger researchLogger = getInstance(); - researchLogger.commitCurrentLogUnitAsWord(doubleSpace, Long.MAX_VALUE); + private static final LogStatement LOGSTATEMENT_RICHINPUTCONNECTION_REVERTDOUBLESPACEPERIOD = + new LogStatement("RichInputConnectionRevertDoubleSpacePeriod", false, false); + public static void richInputConnection_revertDoubleSpacePeriod() { + getInstance().enqueueEvent(LOGSTATEMENT_RICHINPUTCONNECTION_REVERTDOUBLESPACEPERIOD); } /** @@ -1305,9 +1440,10 @@ public class ResearchLogger implements SharedPreferences.OnSharedPreferenceChang * * SystemResponse: The IME has reverted a punctuation swap. */ - public static void richInputConnection_revertSwapPunctuation(final String text) { - final ResearchLogger researchLogger = getInstance(); - researchLogger.commitCurrentLogUnitAsWord(text, Long.MAX_VALUE); + private static final LogStatement LOGSTATEMENT_RICHINPUTCONNECTION_REVERTSWAPPUNCTUATION = + new LogStatement("RichInputConnectionRevertSwapPunctuation", false, false); + public static void richInputConnection_revertSwapPunctuation() { + getInstance().enqueueEvent(LOGSTATEMENT_RICHINPUTCONNECTION_REVERTSWAPPUNCTUATION); } /** @@ -1317,16 +1453,24 @@ public class ResearchLogger implements SharedPreferences.OnSharedPreferenceChang * text input to another word that the user more likely desired to type. */ private static final LogStatement LOGSTATEMENT_LATINIME_COMMITCURRENTAUTOCORRECTION = - new LogStatement("LatinIMECommitCurrentAutoCorrection", true, false, "typedWord", + new LogStatement("LatinIMECommitCurrentAutoCorrection", true, true, "typedWord", "autoCorrection", "separatorString"); public static void latinIme_commitCurrentAutoCorrection(final String typedWord, - final String autoCorrection, final String separatorString) { + final String autoCorrection, final String separatorString, final boolean isBatchMode) { final String scrubbedTypedWord = scrubDigitsFromString(typedWord); final String scrubbedAutoCorrection = scrubDigitsFromString(autoCorrection); final ResearchLogger researchLogger = getInstance(); - researchLogger.enqueueEvent(LOGSTATEMENT_LATINIME_COMMITCURRENTAUTOCORRECTION, + researchLogger.commitCurrentLogUnitAsWord(scrubbedAutoCorrection, Long.MAX_VALUE, + isBatchMode); + + // Add the autocorrection logStatement at the end of the logUnit for the committed word. + // We have to do this after calling commitCurrentLogUnitAsWord, because it may split the + // current logUnit, and then we have to peek to get the logUnit reference back. + final LogUnit logUnit = researchLogger.mMainLogBuffer.peekLastLogUnit(); + // TODO: Add test to confirm that the commitCurrentAutoCorrection log statement should + // always be added to logUnit (if non-null) and not mCurrentLogUnit. + researchLogger.enqueueEvent(logUnit, LOGSTATEMENT_LATINIME_COMMITCURRENTAUTOCORRECTION, scrubbedTypedWord, scrubbedAutoCorrection, separatorString); - researchLogger.commitCurrentLogUnitAsWord(scrubbedAutoCorrection, Long.MAX_VALUE); } private boolean isExpectingCommitText = false; @@ -1340,13 +1484,13 @@ public class ResearchLogger implements SharedPreferences.OnSharedPreferenceChang // add invocations. private static final LogStatement LOGSTATEMENT_LATINIME_COMMIT_PARTIAL_TEXT = new LogStatement("LatinIMECommitPartialText", true, false, "newCursorPosition"); - public static void latinIME_commitPartialText(final CharSequence committedWord, - final long lastTimestampOfWordData) { + public static void latinIME_commitPartialText(final String committedWord, + final long lastTimestampOfWordData, final boolean isBatchMode) { final ResearchLogger researchLogger = getInstance(); - final String scrubbedWord = scrubDigitsFromString(committedWord.toString()); + final String scrubbedWord = scrubDigitsFromString(committedWord); researchLogger.enqueueEvent(LOGSTATEMENT_LATINIME_COMMIT_PARTIAL_TEXT); - researchLogger.commitCurrentLogUnitAsWord(scrubbedWord, lastTimestampOfWordData); - researchLogger.mStatistics.recordSplitWords(); + researchLogger.commitCurrentLogUnitAsWord(scrubbedWord, lastTimestampOfWordData, + isBatchMode); } /** @@ -1357,14 +1501,14 @@ public class ResearchLogger implements SharedPreferences.OnSharedPreferenceChang */ private static final LogStatement LOGSTATEMENT_RICHINPUTCONNECTIONCOMMITTEXT = new LogStatement("RichInputConnectionCommitText", true, false, "newCursorPosition"); - public static void richInputConnection_commitText(final CharSequence committedWord, - final int newCursorPosition) { + public static void richInputConnection_commitText(final String committedWord, + final int newCursorPosition, final boolean isBatchMode) { final ResearchLogger researchLogger = getInstance(); - final String scrubbedWord = scrubDigitsFromString(committedWord.toString()); + final String scrubbedWord = scrubDigitsFromString(committedWord); if (!researchLogger.isExpectingCommitText) { researchLogger.enqueueEvent(LOGSTATEMENT_RICHINPUTCONNECTIONCOMMITTEXT, newCursorPosition); - researchLogger.commitCurrentLogUnitAsWord(scrubbedWord, Long.MAX_VALUE); + researchLogger.commitCurrentLogUnitAsWord(scrubbedWord, Long.MAX_VALUE, isBatchMode); } researchLogger.isExpectingCommitText = false; } @@ -1373,9 +1517,9 @@ public class ResearchLogger implements SharedPreferences.OnSharedPreferenceChang * Shared event for logging committed text. */ private static final LogStatement LOGSTATEMENT_COMMITTEXT = - new LogStatement("CommitText", true, false, "committedText"); - private void enqueueCommitText(final CharSequence word) { - enqueueEvent(LOGSTATEMENT_COMMITTEXT, word); + new LogStatement("CommitText", true, false, "committedText", "isBatchMode"); + private void enqueueCommitText(final String word, final boolean isBatchMode) { + enqueueEvent(LOGSTATEMENT_COMMITTEXT, word, isBatchMode); } /** @@ -1515,20 +1659,62 @@ public class ResearchLogger implements SharedPreferences.OnSharedPreferenceChang final ResearchLogger researchLogger = getInstance(); researchLogger.enqueueEvent(LOGSTATEMENT_LATINIME_ONENDBATCHINPUT, enteredText, enteredWordPos); - researchLogger.mStatistics.recordGestureInput(enteredText.length()); + researchLogger.mStatistics.recordGestureInput(enteredText.length(), + SystemClock.uptimeMillis()); } /** - * Log a call to LatinIME.handleBackspace(). + * Log a call to LatinIME.handleBackspace() that is not a batch delete. + * + * UserInput: The user is deleting one or more characters by hitting the backspace key once. + * The covers single character deletes as well as deleting selections. + */ + private static final LogStatement LOGSTATEMENT_LATINIME_HANDLEBACKSPACE = + new LogStatement("LatinIMEHandleBackspace", true, false, "numCharacters"); + public static void latinIME_handleBackspace(final int numCharacters) { + final ResearchLogger researchLogger = getInstance(); + researchLogger.enqueueEvent(LOGSTATEMENT_LATINIME_HANDLEBACKSPACE, numCharacters); + } + + /** + * Log a call to LatinIME.handleBackspace() that is a batch delete. * * UserInput: The user is deleting a gestured word by hitting the backspace key once. */ private static final LogStatement LOGSTATEMENT_LATINIME_HANDLEBACKSPACE_BATCH = - new LogStatement("LatinIMEHandleBackspaceBatch", true, false, "deletedText"); - public static void latinIME_handleBackspace_batch(final CharSequence deletedText) { + new LogStatement("LatinIMEHandleBackspaceBatch", true, false, "deletedText", + "numCharacters"); + public static void latinIME_handleBackspace_batch(final CharSequence deletedText, + final int numCharacters) { + final ResearchLogger researchLogger = getInstance(); + researchLogger.enqueueEvent(LOGSTATEMENT_LATINIME_HANDLEBACKSPACE_BATCH, deletedText, + numCharacters); + researchLogger.mStatistics.recordGestureDelete(deletedText.length(), + SystemClock.uptimeMillis()); + } + + /** + * Log a long interval between user operation. + * + * UserInput: The user has not done anything for a while. + */ + private static final LogStatement LOGSTATEMENT_ONUSERPAUSE = new LogStatement("OnUserPause", + false, false, "intervalInMs"); + public static void onUserPause(final long interval) { + final ResearchLogger researchLogger = getInstance(); + researchLogger.enqueueEvent(LOGSTATEMENT_ONUSERPAUSE, interval); + } + + /** + * Record the current time in case the LogUnit is later split. + * + * If the current logUnitis split, then tapping, motion events, etc. before this time should + * be assigned to one LogUnit, and events after this time should go into the following LogUnit. + */ + public static void recordTimeForLogUnitSplit() { final ResearchLogger researchLogger = getInstance(); - researchLogger.enqueueEvent(LOGSTATEMENT_LATINIME_HANDLEBACKSPACE_BATCH, deletedText); - researchLogger.mStatistics.recordGestureDelete(); + researchLogger.setSavedDownEventTime(SystemClock.uptimeMillis()); + researchLogger.mSavedDownEventTime = Long.MAX_VALUE; } /** |