361 lines
14 KiB
Java
361 lines
14 KiB
Java
|
/*
|
||
|
|
* Copyright (C) 2012 The Android Open Source Project
|
||
|
|
*
|
||
|
|
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
|
||
|
|
* use this file except in compliance with the License. You may obtain a copy of
|
||
|
|
* the License at
|
||
|
|
*
|
||
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||
|
|
*
|
||
|
|
* Unless required by applicable law or agreed to in writing, software
|
||
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
||
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
||
|
|
* License for the specific language governing permissions and limitations under
|
||
|
|
* the License.
|
||
|
|
*/
|
||
|
|
|
||
|
|
package com.android.inputmethod.latin;
|
||
|
|
|
||
|
|
import android.content.SharedPreferences;
|
||
|
|
import android.os.SystemClock;
|
||
|
|
import android.util.JsonWriter;
|
||
|
|
import android.util.Log;
|
||
|
|
import android.view.inputmethod.CompletionInfo;
|
||
|
|
|
||
|
|
import com.android.inputmethod.keyboard.Key;
|
||
|
|
import com.android.inputmethod.latin.ResearchLogger.LogUnit;
|
||
|
|
import com.android.inputmethod.latin.SuggestedWords.SuggestedWordInfo;
|
||
|
|
import com.android.inputmethod.latin.define.ProductionFlag;
|
||
|
|
|
||
|
|
import java.io.BufferedWriter;
|
||
|
|
import java.io.File;
|
||
|
|
import java.io.FileWriter;
|
||
|
|
import java.io.IOException;
|
||
|
|
import java.io.OutputStream;
|
||
|
|
import java.io.OutputStreamWriter;
|
||
|
|
import java.util.Map;
|
||
|
|
import java.util.concurrent.Callable;
|
||
|
|
import java.util.concurrent.Executors;
|
||
|
|
import java.util.concurrent.ScheduledExecutorService;
|
||
|
|
import java.util.concurrent.ScheduledFuture;
|
||
|
|
import java.util.concurrent.TimeUnit;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Logs the use of the LatinIME keyboard.
|
||
|
|
*
|
||
|
|
* This class logs operations on the IME keyboard, including what the user has typed.
|
||
|
|
* Data is stored locally in a file in app-specific storage.
|
||
|
|
*
|
||
|
|
* This functionality is off by default. See {@link ProductionFlag#IS_EXPERIMENTAL}.
|
||
|
|
*/
|
||
|
|
public class ResearchLog {
|
||
|
|
private static final String TAG = ResearchLog.class.getSimpleName();
|
||
|
|
private static final JsonWriter NULL_JSON_WRITER = new JsonWriter(
|
||
|
|
new OutputStreamWriter(new NullOutputStream()));
|
||
|
|
|
||
|
|
final ScheduledExecutorService mExecutor;
|
||
|
|
/* package */ final File mFile;
|
||
|
|
private JsonWriter mJsonWriter = NULL_JSON_WRITER; // should never be null
|
||
|
|
|
||
|
|
private int mLoggingState;
|
||
|
|
private static final int LOGGING_STATE_UNSTARTED = 0;
|
||
|
|
private static final int LOGGING_STATE_RUNNING = 1;
|
||
|
|
private static final int LOGGING_STATE_STOPPING = 2;
|
||
|
|
private static final int LOGGING_STATE_STOPPED = 3;
|
||
|
|
private static final long FLUSH_DELAY_IN_MS = 1000 * 5;
|
||
|
|
|
||
|
|
private static class NullOutputStream extends OutputStream {
|
||
|
|
/** {@inheritDoc} */
|
||
|
|
@Override
|
||
|
|
public void write(byte[] buffer, int offset, int count) {
|
||
|
|
// nop
|
||
|
|
}
|
||
|
|
|
||
|
|
/** {@inheritDoc} */
|
||
|
|
@Override
|
||
|
|
public void write(byte[] buffer) {
|
||
|
|
// nop
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public void write(int oneByte) {
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public ResearchLog(File outputFile) {
|
||
|
|
mExecutor = Executors.newSingleThreadScheduledExecutor();
|
||
|
|
if (outputFile == null) {
|
||
|
|
throw new IllegalArgumentException();
|
||
|
|
}
|
||
|
|
mFile = outputFile;
|
||
|
|
mLoggingState = LOGGING_STATE_UNSTARTED;
|
||
|
|
}
|
||
|
|
|
||
|
|
public synchronized void start() throws IOException {
|
||
|
|
switch (mLoggingState) {
|
||
|
|
case LOGGING_STATE_UNSTARTED:
|
||
|
|
mJsonWriter = new JsonWriter(new BufferedWriter(new FileWriter(mFile)));
|
||
|
|
mJsonWriter.setLenient(true);
|
||
|
|
mJsonWriter.beginArray();
|
||
|
|
mLoggingState = LOGGING_STATE_RUNNING;
|
||
|
|
break;
|
||
|
|
case LOGGING_STATE_RUNNING:
|
||
|
|
case LOGGING_STATE_STOPPING:
|
||
|
|
case LOGGING_STATE_STOPPED:
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public synchronized void stop() {
|
||
|
|
switch (mLoggingState) {
|
||
|
|
case LOGGING_STATE_UNSTARTED:
|
||
|
|
mLoggingState = LOGGING_STATE_STOPPED;
|
||
|
|
break;
|
||
|
|
case LOGGING_STATE_RUNNING:
|
||
|
|
mExecutor.submit(new Callable<Object>() {
|
||
|
|
@Override
|
||
|
|
public Object call() throws Exception {
|
||
|
|
try {
|
||
|
|
mJsonWriter.endArray();
|
||
|
|
mJsonWriter.flush();
|
||
|
|
mJsonWriter.close();
|
||
|
|
} finally {
|
||
|
|
// the contentprovider only exports data if the writable
|
||
|
|
// bit is cleared.
|
||
|
|
boolean success = mFile.setWritable(false, false);
|
||
|
|
mLoggingState = LOGGING_STATE_STOPPED;
|
||
|
|
}
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
mExecutor.shutdown();
|
||
|
|
mLoggingState = LOGGING_STATE_STOPPING;
|
||
|
|
break;
|
||
|
|
case LOGGING_STATE_STOPPING:
|
||
|
|
case LOGGING_STATE_STOPPED:
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public boolean isAlive() {
|
||
|
|
switch (mLoggingState) {
|
||
|
|
case LOGGING_STATE_UNSTARTED:
|
||
|
|
case LOGGING_STATE_RUNNING:
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
public void waitUntilStopped(int timeoutInMs) throws InterruptedException {
|
||
|
|
mExecutor.awaitTermination(timeoutInMs, TimeUnit.MILLISECONDS);
|
||
|
|
}
|
||
|
|
|
||
|
|
private boolean isAbortSuccessful;
|
||
|
|
public boolean isAbortSuccessful() {
|
||
|
|
return isAbortSuccessful;
|
||
|
|
}
|
||
|
|
|
||
|
|
public synchronized void abort() {
|
||
|
|
switch (mLoggingState) {
|
||
|
|
case LOGGING_STATE_UNSTARTED:
|
||
|
|
mLoggingState = LOGGING_STATE_STOPPED;
|
||
|
|
isAbortSuccessful = true;
|
||
|
|
break;
|
||
|
|
case LOGGING_STATE_RUNNING:
|
||
|
|
mExecutor.submit(new Callable<Object>() {
|
||
|
|
@Override
|
||
|
|
public Object call() throws Exception {
|
||
|
|
try {
|
||
|
|
mJsonWriter.endArray();
|
||
|
|
mJsonWriter.close();
|
||
|
|
} finally {
|
||
|
|
isAbortSuccessful = mFile.delete();
|
||
|
|
}
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
mExecutor.shutdown();
|
||
|
|
mLoggingState = LOGGING_STATE_STOPPING;
|
||
|
|
break;
|
||
|
|
case LOGGING_STATE_STOPPING:
|
||
|
|
case LOGGING_STATE_STOPPED:
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* package */ synchronized void flush() {
|
||
|
|
switch (mLoggingState) {
|
||
|
|
case LOGGING_STATE_UNSTARTED:
|
||
|
|
break;
|
||
|
|
case LOGGING_STATE_RUNNING:
|
||
|
|
removeAnyScheduledFlush();
|
||
|
|
mExecutor.submit(mFlushCallable);
|
||
|
|
break;
|
||
|
|
case LOGGING_STATE_STOPPING:
|
||
|
|
case LOGGING_STATE_STOPPED:
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private Callable<Object> mFlushCallable = new Callable<Object>() {
|
||
|
|
@Override
|
||
|
|
public Object call() throws Exception {
|
||
|
|
mJsonWriter.flush();
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
private ScheduledFuture<Object> mFlushFuture;
|
||
|
|
|
||
|
|
private void removeAnyScheduledFlush() {
|
||
|
|
if (mFlushFuture != null) {
|
||
|
|
mFlushFuture.cancel(false);
|
||
|
|
mFlushFuture = null;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void scheduleFlush() {
|
||
|
|
removeAnyScheduledFlush();
|
||
|
|
mFlushFuture = mExecutor.schedule(mFlushCallable, FLUSH_DELAY_IN_MS, TimeUnit.MILLISECONDS);
|
||
|
|
}
|
||
|
|
|
||
|
|
public synchronized void publishPublicEvents(final LogUnit logUnit) {
|
||
|
|
switch (mLoggingState) {
|
||
|
|
case LOGGING_STATE_UNSTARTED:
|
||
|
|
break;
|
||
|
|
case LOGGING_STATE_RUNNING:
|
||
|
|
mExecutor.submit(new Callable<Object>() {
|
||
|
|
@Override
|
||
|
|
public Object call() throws Exception {
|
||
|
|
logUnit.publishPublicEventsTo(ResearchLog.this);
|
||
|
|
scheduleFlush();
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
break;
|
||
|
|
case LOGGING_STATE_STOPPING:
|
||
|
|
case LOGGING_STATE_STOPPED:
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public synchronized void publishAllEvents(final LogUnit logUnit) {
|
||
|
|
switch (mLoggingState) {
|
||
|
|
case LOGGING_STATE_UNSTARTED:
|
||
|
|
break;
|
||
|
|
case LOGGING_STATE_RUNNING:
|
||
|
|
mExecutor.submit(new Callable<Object>() {
|
||
|
|
@Override
|
||
|
|
public Object call() throws Exception {
|
||
|
|
logUnit.publishAllEventsTo(ResearchLog.this);
|
||
|
|
scheduleFlush();
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
break;
|
||
|
|
case LOGGING_STATE_STOPPING:
|
||
|
|
case LOGGING_STATE_STOPPED:
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private static final String CURRENT_TIME_KEY = "_ct";
|
||
|
|
private static final String UPTIME_KEY = "_ut";
|
||
|
|
private static final String EVENT_TYPE_KEY = "_ty";
|
||
|
|
void outputEvent(final String[] keys, final Object[] values) {
|
||
|
|
// not thread safe.
|
||
|
|
try {
|
||
|
|
mJsonWriter.beginObject();
|
||
|
|
mJsonWriter.name(CURRENT_TIME_KEY).value(System.currentTimeMillis());
|
||
|
|
mJsonWriter.name(UPTIME_KEY).value(SystemClock.uptimeMillis());
|
||
|
|
mJsonWriter.name(EVENT_TYPE_KEY).value(keys[0]);
|
||
|
|
final int length = values.length;
|
||
|
|
for (int i = 0; i < length; i++) {
|
||
|
|
mJsonWriter.name(keys[i + 1]);
|
||
|
|
Object value = values[i];
|
||
|
|
if (value instanceof String) {
|
||
|
|
mJsonWriter.value((String) value);
|
||
|
|
} else if (value instanceof Number) {
|
||
|
|
mJsonWriter.value((Number) value);
|
||
|
|
} else if (value instanceof Boolean) {
|
||
|
|
mJsonWriter.value((Boolean) value);
|
||
|
|
} else if (value instanceof CompletionInfo[]) {
|
||
|
|
CompletionInfo[] ci = (CompletionInfo[]) value;
|
||
|
|
mJsonWriter.beginArray();
|
||
|
|
for (int j = 0; j < ci.length; j++) {
|
||
|
|
mJsonWriter.value(ci[j].toString());
|
||
|
|
}
|
||
|
|
mJsonWriter.endArray();
|
||
|
|
} else if (value instanceof SharedPreferences) {
|
||
|
|
SharedPreferences prefs = (SharedPreferences) value;
|
||
|
|
mJsonWriter.beginObject();
|
||
|
|
for (Map.Entry<String,?> entry : prefs.getAll().entrySet()) {
|
||
|
|
mJsonWriter.name(entry.getKey());
|
||
|
|
final Object innerValue = entry.getValue();
|
||
|
|
if (innerValue == null) {
|
||
|
|
mJsonWriter.nullValue();
|
||
|
|
} else if (innerValue instanceof Boolean) {
|
||
|
|
mJsonWriter.value((Boolean) innerValue);
|
||
|
|
} else if (innerValue instanceof Number) {
|
||
|
|
mJsonWriter.value((Number) innerValue);
|
||
|
|
} else {
|
||
|
|
mJsonWriter.value(innerValue.toString());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
mJsonWriter.endObject();
|
||
|
|
} else if (value instanceof Key[]) {
|
||
|
|
Key[] keyboardKeys = (Key[]) value;
|
||
|
|
mJsonWriter.beginArray();
|
||
|
|
for (Key keyboardKey : keyboardKeys) {
|
||
|
|
mJsonWriter.beginObject();
|
||
|
|
mJsonWriter.name("code").value(keyboardKey.mCode);
|
||
|
|
mJsonWriter.name("altCode").value(keyboardKey.mAltCode);
|
||
|
|
mJsonWriter.name("x").value(keyboardKey.mX);
|
||
|
|
mJsonWriter.name("y").value(keyboardKey.mY);
|
||
|
|
mJsonWriter.name("w").value(keyboardKey.mWidth);
|
||
|
|
mJsonWriter.name("h").value(keyboardKey.mHeight);
|
||
|
|
mJsonWriter.endObject();
|
||
|
|
}
|
||
|
|
mJsonWriter.endArray();
|
||
|
|
} else if (value instanceof SuggestedWords) {
|
||
|
|
SuggestedWords words = (SuggestedWords) value;
|
||
|
|
mJsonWriter.beginObject();
|
||
|
|
mJsonWriter.name("typedWordValid").value(words.mTypedWordValid);
|
||
|
|
mJsonWriter.name("willAutoCorrect")
|
||
|
|
.value(words.mWillAutoCorrect);
|
||
|
|
mJsonWriter.name("isPunctuationSuggestions")
|
||
|
|
.value(words.mIsPunctuationSuggestions);
|
||
|
|
mJsonWriter.name("isObsoleteSuggestions")
|
||
|
|
.value(words.mIsObsoleteSuggestions);
|
||
|
|
mJsonWriter.name("isPrediction")
|
||
|
|
.value(words.mIsPrediction);
|
||
|
|
mJsonWriter.name("words");
|
||
|
|
mJsonWriter.beginArray();
|
||
|
|
final int size = words.size();
|
||
|
|
for (int j = 0; j < size; j++) {
|
||
|
|
SuggestedWordInfo wordInfo = words.getWordInfo(j);
|
||
|
|
mJsonWriter.value(wordInfo.toString());
|
||
|
|
}
|
||
|
|
mJsonWriter.endArray();
|
||
|
|
mJsonWriter.endObject();
|
||
|
|
} else if (value == null) {
|
||
|
|
mJsonWriter.nullValue();
|
||
|
|
} else {
|
||
|
|
Log.w(TAG, "Unrecognized type to be logged: " +
|
||
|
|
(value == null ? "<null>" : value.getClass().getName()));
|
||
|
|
mJsonWriter.nullValue();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
mJsonWriter.endObject();
|
||
|
|
} catch (IOException e) {
|
||
|
|
e.printStackTrace();
|
||
|
|
Log.w(TAG, "Error in JsonWriter; disabling logging");
|
||
|
|
try {
|
||
|
|
mJsonWriter.close();
|
||
|
|
} catch (IllegalStateException e1) {
|
||
|
|
// assume that this is just the json not being terminated properly.
|
||
|
|
// ignore
|
||
|
|
} catch (IOException e1) {
|
||
|
|
e1.printStackTrace();
|
||
|
|
} finally {
|
||
|
|
mJsonWriter = NULL_JSON_WRITER;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|