293 lines
10 KiB
Java
293 lines
10 KiB
Java
/*
|
|
* Copyright (C) 2016 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.utils;
|
|
|
|
import android.content.Intent;
|
|
import android.content.pm.PackageManager;
|
|
import android.inputmethodservice.InputMethodService;
|
|
import android.net.Uri;
|
|
import android.os.Environment;
|
|
import android.os.Handler;
|
|
import android.os.HandlerThread;
|
|
import android.os.Process;
|
|
import android.util.Log;
|
|
import android.view.MotionEvent;
|
|
|
|
import com.android.inputmethod.latin.LatinImeLogger;
|
|
|
|
import java.io.BufferedReader;
|
|
import java.io.File;
|
|
import java.io.FileInputStream;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.FileOutputStream;
|
|
import java.io.FileReader;
|
|
import java.io.IOException;
|
|
import java.io.PrintWriter;
|
|
import java.nio.channels.FileChannel;
|
|
import java.text.SimpleDateFormat;
|
|
import java.util.Date;
|
|
import java.util.Locale;
|
|
|
|
public final class UsabilityStudyLogUtils {
|
|
// TODO: remove code duplication with ResearchLog class
|
|
private static final String USABILITY_TAG = UsabilityStudyLogUtils.class.getSimpleName();
|
|
private static final String FILENAME = "log.txt";
|
|
private final Handler mLoggingHandler;
|
|
private File mFile;
|
|
private File mDirectory;
|
|
private InputMethodService mIms;
|
|
private PrintWriter mWriter;
|
|
private final Date mDate;
|
|
private final SimpleDateFormat mDateFormat;
|
|
|
|
private UsabilityStudyLogUtils() {
|
|
mDate = new Date();
|
|
mDateFormat = new SimpleDateFormat("yyyyMMdd-HHmmss.SSSZ", Locale.US);
|
|
|
|
HandlerThread handlerThread = new HandlerThread("UsabilityStudyLogUtils logging task",
|
|
Process.THREAD_PRIORITY_BACKGROUND);
|
|
handlerThread.start();
|
|
mLoggingHandler = new Handler(handlerThread.getLooper());
|
|
}
|
|
|
|
// Initialization-on-demand holder
|
|
private static final class OnDemandInitializationHolder {
|
|
public static final UsabilityStudyLogUtils sInstance = new UsabilityStudyLogUtils();
|
|
}
|
|
|
|
public static UsabilityStudyLogUtils getInstance() {
|
|
return OnDemandInitializationHolder.sInstance;
|
|
}
|
|
|
|
public void init(final InputMethodService ims) {
|
|
mIms = ims;
|
|
mDirectory = ims.getFilesDir();
|
|
}
|
|
|
|
private void createLogFileIfNotExist() {
|
|
if ((mFile == null || !mFile.exists())
|
|
&& (mDirectory != null && mDirectory.exists())) {
|
|
try {
|
|
mWriter = getPrintWriter(mDirectory, FILENAME, false);
|
|
} catch (final IOException e) {
|
|
Log.e(USABILITY_TAG, "Can't create log file.");
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void writeBackSpace(final int x, final int y) {
|
|
UsabilityStudyLogUtils.getInstance().write("<backspace>\t" + x + "\t" + y);
|
|
}
|
|
|
|
public static void writeChar(final char c, final int x, final int y) {
|
|
String inputChar = String.valueOf(c);
|
|
switch (c) {
|
|
case '\n':
|
|
inputChar = "<enter>";
|
|
break;
|
|
case '\t':
|
|
inputChar = "<tab>";
|
|
break;
|
|
case ' ':
|
|
inputChar = "<space>";
|
|
break;
|
|
}
|
|
UsabilityStudyLogUtils.getInstance().write(inputChar + "\t" + x + "\t" + y);
|
|
LatinImeLogger.onPrintAllUsabilityStudyLogs();
|
|
}
|
|
|
|
public static void writeMotionEvent(final MotionEvent me) {
|
|
final int action = me.getActionMasked();
|
|
final long eventTime = me.getEventTime();
|
|
final int pointerCount = me.getPointerCount();
|
|
for (int index = 0; index < pointerCount; index++) {
|
|
final int id = me.getPointerId(index);
|
|
final int x = (int)me.getX(index);
|
|
final int y = (int)me.getY(index);
|
|
final float size = me.getSize(index);
|
|
final float pressure = me.getPressure(index);
|
|
|
|
final String eventTag;
|
|
switch (action) {
|
|
case MotionEvent.ACTION_UP:
|
|
eventTag = "[Up]";
|
|
break;
|
|
case MotionEvent.ACTION_DOWN:
|
|
eventTag = "[Down]";
|
|
break;
|
|
case MotionEvent.ACTION_POINTER_UP:
|
|
eventTag = "[PointerUp]";
|
|
break;
|
|
case MotionEvent.ACTION_POINTER_DOWN:
|
|
eventTag = "[PointerDown]";
|
|
break;
|
|
case MotionEvent.ACTION_MOVE:
|
|
eventTag = "[Move]";
|
|
break;
|
|
default:
|
|
eventTag = "[Action" + action + "]";
|
|
break;
|
|
}
|
|
getInstance().write(eventTag + eventTime + "," + id + "," + x + "," + y + "," + size
|
|
+ "," + pressure);
|
|
}
|
|
}
|
|
|
|
public void write(final String log) {
|
|
mLoggingHandler.post(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
createLogFileIfNotExist();
|
|
final long currentTime = System.currentTimeMillis();
|
|
mDate.setTime(currentTime);
|
|
|
|
final String printString = String.format(Locale.US, "%s\t%d\t%s\n",
|
|
mDateFormat.format(mDate), currentTime, log);
|
|
if (LatinImeLogger.sDBG) {
|
|
Log.d(USABILITY_TAG, "Write: " + log);
|
|
}
|
|
mWriter.print(printString);
|
|
}
|
|
});
|
|
}
|
|
|
|
private synchronized String getBufferedLogs() {
|
|
mWriter.flush();
|
|
final StringBuilder sb = new StringBuilder();
|
|
final BufferedReader br = getBufferedReader();
|
|
String line;
|
|
try {
|
|
while ((line = br.readLine()) != null) {
|
|
sb.append('\n');
|
|
sb.append(line);
|
|
}
|
|
} catch (final IOException e) {
|
|
Log.e(USABILITY_TAG, "Can't read log file.");
|
|
} finally {
|
|
if (LatinImeLogger.sDBG) {
|
|
Log.d(USABILITY_TAG, "Got all buffered logs\n" + sb.toString());
|
|
}
|
|
try {
|
|
br.close();
|
|
} catch (final IOException e) {
|
|
// ignore.
|
|
}
|
|
}
|
|
return sb.toString();
|
|
}
|
|
|
|
public void emailResearcherLogsAll() {
|
|
mLoggingHandler.post(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
final Date date = new Date();
|
|
date.setTime(System.currentTimeMillis());
|
|
final String currentDateTimeString =
|
|
new SimpleDateFormat("yyyyMMdd-HHmmssZ", Locale.US).format(date);
|
|
if (mFile == null) {
|
|
Log.w(USABILITY_TAG, "No internal log file found.");
|
|
return;
|
|
}
|
|
if (mIms.checkCallingOrSelfPermission(
|
|
android.Manifest.permission.WRITE_EXTERNAL_STORAGE)
|
|
!= PackageManager.PERMISSION_GRANTED) {
|
|
Log.w(USABILITY_TAG, "Doesn't have the permission WRITE_EXTERNAL_STORAGE");
|
|
return;
|
|
}
|
|
mWriter.flush();
|
|
final String destPath = Environment.getExternalStorageDirectory()
|
|
+ "/research-" + currentDateTimeString + ".log";
|
|
final File destFile = new File(destPath);
|
|
try {
|
|
final FileInputStream srcStream = new FileInputStream(mFile);
|
|
final FileOutputStream destStream = new FileOutputStream(destFile);
|
|
final FileChannel src = srcStream.getChannel();
|
|
final FileChannel dest = destStream.getChannel();
|
|
src.transferTo(0, src.size(), dest);
|
|
src.close();
|
|
srcStream.close();
|
|
dest.close();
|
|
destStream.close();
|
|
} catch (final FileNotFoundException e1) {
|
|
Log.w(USABILITY_TAG, e1);
|
|
return;
|
|
} catch (final IOException e2) {
|
|
Log.w(USABILITY_TAG, e2);
|
|
return;
|
|
}
|
|
if (!destFile.exists()) {
|
|
Log.w(USABILITY_TAG, "Dest file doesn't exist.");
|
|
return;
|
|
}
|
|
final Intent intent = new Intent(Intent.ACTION_SEND);
|
|
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
|
|
if (LatinImeLogger.sDBG) {
|
|
Log.d(USABILITY_TAG, "Destination file URI is " + destFile.toURI());
|
|
}
|
|
intent.setType("text/plain");
|
|
intent.putExtra(Intent.EXTRA_STREAM, Uri.parse("file://" + destPath));
|
|
intent.putExtra(Intent.EXTRA_SUBJECT,
|
|
"[Research Logs] " + currentDateTimeString);
|
|
mIms.startActivity(intent);
|
|
}
|
|
});
|
|
}
|
|
|
|
public void printAll() {
|
|
mLoggingHandler.post(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
mIms.getCurrentInputConnection().commitText(getBufferedLogs(), 0);
|
|
}
|
|
});
|
|
}
|
|
|
|
public void clearAll() {
|
|
mLoggingHandler.post(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
if (mFile != null && mFile.exists()) {
|
|
if (LatinImeLogger.sDBG) {
|
|
Log.d(USABILITY_TAG, "Delete log file.");
|
|
}
|
|
mFile.delete();
|
|
mWriter.close();
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
private BufferedReader getBufferedReader() {
|
|
createLogFileIfNotExist();
|
|
try {
|
|
return new BufferedReader(new FileReader(mFile));
|
|
} catch (final FileNotFoundException e) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private PrintWriter getPrintWriter(final File dir, final String filename,
|
|
final boolean renew) throws IOException {
|
|
mFile = new File(dir, filename);
|
|
if (mFile.exists()) {
|
|
if (renew) {
|
|
mFile.delete();
|
|
}
|
|
}
|
|
return new PrintWriter(new FileOutputStream(mFile), true /* autoFlush */);
|
|
}
|
|
}
|