android/WALT/app/src/main/java/org/chromium/latency/walt/TapLatencyFragment.java - platform/external/walt - Git at Google

 /*
  * Copyright (C) 2015 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 org.chromium.latency.walt;

 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.os.Bundle;
 import android.support.v4.app.Fragment;
 import android.text.method.ScrollingMovementMethod;
 import android.view.LayoutInflater;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.ViewGroup;
 import android.widget.ImageButton;
 import android.widget.TextView;

 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Locale;

 import static org.chromium.latency.walt.Utils.getBooleanPreference;

 public class TapLatencyFragment extends Fragment
         implements View.OnClickListener, RobotAutomationListener {

     private static final int ACTION_DOWN_INDEX = 0;
     private static final int ACTION_UP_INDEX = 1;
     private SimpleLogger logger;
     private TraceLogger traceLogger;
     private WaltDevice waltDevice;
     private TextView logTextView;
     private TextView tapCatcherView;
     private TextView tapCountsView;
     private TextView moveCountsView;
     private ImageButton finishButton;
     private ImageButton restartButton;
     private HistogramChart latencyChart;
     private int moveCount = 0;
     private int allDownCount = 0;
     private int allUpCount = 0;
     private int okDownCount = 0;
     private int okUpCount = 0;
     private boolean shouldShowLatencyChart = false;

     ArrayList<UsMotionEvent> eventList = new ArrayList<>();
     ArrayList<Double> p2kDown = new ArrayList<>();
     ArrayList<Double> p2kUp = new ArrayList<>();
     ArrayList<Double> k2cDown = new ArrayList<>();
     ArrayList<Double> k2cUp = new ArrayList<>();

     private BroadcastReceiver logReceiver = new BroadcastReceiver() {
         @Override
         public void onReceive(Context context, Intent intent) {
             String msg = intent.getStringExtra("message");
             TapLatencyFragment.this.appendLogText(msg);
         }
     };

     private View.OnTouchListener touchListener = new View.OnTouchListener() {
         @Override
         public boolean onTouch(View v, MotionEvent event) {
             UsMotionEvent tapEvent = new UsMotionEvent(event, waltDevice.clock.baseTime);

             if(tapEvent.action != MotionEvent.ACTION_UP && tapEvent.action != MotionEvent.ACTION_DOWN) {
                 moveCount++;
                 updateCountsDisplay();
                 return true;
             }

             // Debug: logger.log("\n"+ action + " event received: " + tapEvent.toStringLong());
             tapEvent.physicalTime = waltDevice.readLastShockTime();

             tapEvent.isOk = checkTapSanity(tapEvent);
             // Save it in any case so we can do stats on bad events later
             eventList.add(tapEvent);

             final double physicalToKernelTime = (tapEvent.kernelTime - tapEvent.physicalTime) / 1000.;
             final double kernelToCallbackTime = (tapEvent.createTime - tapEvent.kernelTime) / 1000.;
             if (tapEvent.action == MotionEvent.ACTION_DOWN) {
                 allDownCount++;
                 if (tapEvent.isOk) {
                     okDownCount++;
                     p2kDown.add(physicalToKernelTime);
                     k2cDown.add(kernelToCallbackTime);
                     if (shouldShowLatencyChart) latencyChart.addEntry(ACTION_DOWN_INDEX, physicalToKernelTime);
                     logger.log(String.format(Locale.US,
                             "ACTION_DOWN:\ntouch2kernel: %.1f ms\nkernel2java: %.1f ms",
                             physicalToKernelTime, kernelToCallbackTime));
                 }
             } else if (tapEvent.action == MotionEvent.ACTION_UP) {
                 allUpCount++;
                 if (tapEvent.isOk) {
                     okUpCount++;
                     p2kUp.add(physicalToKernelTime);
                     k2cUp.add(kernelToCallbackTime);
                     if (shouldShowLatencyChart) latencyChart.addEntry(ACTION_UP_INDEX, physicalToKernelTime);
                     logger.log(String.format(Locale.US,
                             "ACTION_UP:\ntouch2kernel: %.1f ms\nkernel2java: %.1f ms",
                             physicalToKernelTime, kernelToCallbackTime));
                 }
             }
             traceLogEvent(tapEvent);

             updateCountsDisplay();
             return true;
         }
     };

     private void traceLogEvent(UsMotionEvent tapEvent) {
         if (!tapEvent.isOk) return;
         if (traceLogger == null) return;
         if (tapEvent.action != MotionEvent.ACTION_DOWN && tapEvent.action != MotionEvent.ACTION_UP) return;
         final String title = tapEvent.action == MotionEvent.ACTION_UP ? "Tap-Up" : "Tap-Down";
         traceLogger.log(tapEvent.physicalTime + waltDevice.clock.baseTime,
                 tapEvent.kernelTime + waltDevice.clock.baseTime, title + " Physical",
                 "Bar starts at accelerometer shock and ends at kernel time of tap event");
         traceLogger.log(tapEvent.kernelTime + waltDevice.clock.baseTime,
                 tapEvent.createTime + waltDevice.clock.baseTime, title + " App Callback",
                 "Bar starts at kernel time of tap event and ends at app callback time");
     }

     public TapLatencyFragment() {
         // Required empty public constructor
     }

     @Override
     public View onCreateView(LayoutInflater inflater, ViewGroup container,
                              Bundle savedInstanceState) {
         shouldShowLatencyChart = getBooleanPreference(getContext(), R.string.preference_show_tap_histogram, true);
         if (getBooleanPreference(getContext(), R.string.preference_systrace, true)) {
             traceLogger = TraceLogger.getInstance();
         }
         waltDevice = WaltDevice.getInstance(getContext());
         logger = SimpleLogger.getInstance(getContext());
         // Inflate the layout for this fragment
         final View view = inflater.inflate(R.layout.fragment_tap_latency, container, false);
         restartButton = (ImageButton) view.findViewById(R.id.button_restart_tap);
         finishButton = (ImageButton) view.findViewById(R.id.button_finish_tap);
         tapCatcherView = (TextView) view.findViewById(R.id.tap_catcher);
         logTextView = (TextView) view.findViewById(R.id.txt_log_tap_latency);
         tapCountsView = (TextView) view.findViewById(R.id.txt_tap_counts);
         moveCountsView = (TextView) view.findViewById(R.id.txt_move_count);
         latencyChart = (HistogramChart) view.findViewById(R.id.latency_chart);
         logTextView.setMovementMethod(new ScrollingMovementMethod());
         finishButton.setEnabled(false);
         return view;
     }

     @Override
     public void onResume() {
         super.onResume();

         logTextView.setText(logger.getLogText());
         logger.registerReceiver(logReceiver);

         // Register this fragment class as the listener for some button clicks
         restartButton.setOnClickListener(this);
         finishButton.setOnClickListener(this);
     }

     @Override
     public void onPause() {
         logger.unregisterReceiver(logReceiver);
         super.onPause();
     }

     public void appendLogText(String msg) {
         logTextView.append(msg + "\n");
     }

     public boolean checkTapSanity(UsMotionEvent e) {
         String action = e.getActionString();
         double dt = (e.kernelTime - e.physicalTime) / 1000.0;

         if (e.physicalTime == 0) {
             logger.log(action + " no shock found");
             return false;
         }

         if (dt < 0 || dt > 200) {
             logger.log(action + " bogus kernelTime=" + e.kernelTime + ", ignored, dt=" + dt);
             return false;
         }
         return true;
     }

     void updateCountsDisplay() {
         String tpl = "N ↓%d (%d)  ↑%d (%d)";
         tapCountsView.setText(String.format(Locale.US,
                 tpl,
                 okDownCount,
                 allDownCount,
                 okUpCount,
                 allUpCount
                 ));

         moveCountsView.setText(String.format(Locale.US, "⇄ %d", moveCount));
     }

     void restartMeasurement() {
         logger.log("\n## Restarting tap latency measurement. Re-sync clocks ...");
         try {
             waltDevice.softReset();
             waltDevice.syncClock();
         } catch (IOException e) {
             logger.log("Error syncing clocks: " + e.getMessage());
             restartButton.setImageResource(R.drawable.ic_play_arrow_black_24dp);
             finishButton.setEnabled(false);
             latencyChart.setVisibility(View.GONE);
             return;
         }

         eventList.clear();
         p2kDown.clear();
         p2kUp.clear();
         k2cDown.clear();
         k2cUp.clear();

         moveCount = 0;
         allDownCount = 0;
         allUpCount = 0;
         okDownCount = 0;
         okUpCount = 0;

         updateCountsDisplay();
         tapCatcherView.setOnTouchListener(touchListener);
     }

     void finishAndShowStats() {
         tapCatcherView.setOnTouchListener(null);
         waltDevice.checkDrift();
         logger.log("\n-------------------------------");
         logger.log(String.format(Locale.US,
                 "Tap latency results:\n" +
                         "Number of events recorded:\n" +
                         "   ACTION_DOWN %d (bad %d)\n" +
                         "   ACTION_UP %d (bad %d)\n" +
                         "   ACTION_MOVE %d",
                 okDownCount,
                 allDownCount - okDownCount,
                 okUpCount,
                 allUpCount - okUpCount,
                 moveCount
         ));

         logger.log("ACTION_DOWN median times:");
         logger.log(String.format(Locale.US,
                 "   Touch to kernel: %.1f ms\n   Kernel to Java: %.1f ms",
                 Utils.median(p2kDown),
                 Utils.median(k2cDown)
         ));
         logger.log("ACTION_UP median times:");
         logger.log(String.format(Locale.US,
                 "   Touch to kernel: %.1f ms\n   Kernel to Java: %.1f ms",
                 Utils.median(p2kUp),
                 Utils.median(k2cUp)
         ));
         logger.log("-------------------------------");
         if (traceLogger != null) traceLogger.flush(getContext());

         if (shouldShowLatencyChart) {
             latencyChart.setLabel(ACTION_DOWN_INDEX, String.format(Locale.US, "ACTION_DOWN median=%.1f ms", Utils.median(p2kDown)));
             latencyChart.setLabel(ACTION_UP_INDEX, String.format(Locale.US, "ACTION_UP median=%.1f ms", Utils.median(p2kUp)));
         }
         LogUploader.uploadIfAutoEnabled(getContext());
     }

     @Override
     public void onClick(View v) {
         if (v.getId() == R.id.button_restart_tap) {
             restartButton.setImageResource(R.drawable.ic_refresh_black_24dp);
             finishButton.setEnabled(true);
             if (shouldShowLatencyChart) {
                 latencyChart.setVisibility(View.VISIBLE);
                 latencyChart.clearData();
                 latencyChart.setLabel(ACTION_DOWN_INDEX, "ACTION_DOWN");
                 latencyChart.setLabel(ACTION_UP_INDEX, "ACTION_UP");
             }
             restartMeasurement();
             return;
         }

         if (v.getId() == R.id.button_finish_tap) {
             finishButton.setEnabled(false);
             finishAndShowStats();
             restartButton.setImageResource(R.drawable.ic_play_arrow_black_24dp);
             return;
         }

     }

     public void onRobotAutomationEvent(String event) {
         // Never show the latency chart during automated runs.
         shouldShowLatencyChart = false;
         if (event.equals(RobotAutomationListener.RESTART_EVENT) ||
                 event.equals(RobotAutomationListener.START_EVENT)) {
             restartMeasurement();
         } else if (event.equals(RobotAutomationListener.FINISH_EVENT)) {
             finishAndShowStats();
         }
     }
 }
	/*
	* Copyright (C) 2015 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 org.chromium.latency.walt;

	import android.content.BroadcastReceiver;
	import android.content.Context;
	import android.content.Intent;
	import android.os.Bundle;
	import android.support.v4.app.Fragment;
	import android.text.method.ScrollingMovementMethod;
	import android.view.LayoutInflater;
	import android.view.MotionEvent;
	import android.view.View;
	import android.view.ViewGroup;
	import android.widget.ImageButton;
	import android.widget.TextView;

	import java.io.IOException;
	import java.util.ArrayList;
	import java.util.Locale;

	import static org.chromium.latency.walt.Utils.getBooleanPreference;

	public class TapLatencyFragment extends Fragment
	implements View.OnClickListener, RobotAutomationListener {

	private static final int ACTION_DOWN_INDEX = 0;
	private static final int ACTION_UP_INDEX = 1;
	private SimpleLogger logger;
	private TraceLogger traceLogger;
	private WaltDevice waltDevice;
	private TextView logTextView;
	private TextView tapCatcherView;
	private TextView tapCountsView;
	private TextView moveCountsView;
	private ImageButton finishButton;
	private ImageButton restartButton;
	private HistogramChart latencyChart;
	private int moveCount = 0;
	private int allDownCount = 0;
	private int allUpCount = 0;
	private int okDownCount = 0;
	private int okUpCount = 0;
	private boolean shouldShowLatencyChart = false;

	ArrayList<UsMotionEvent> eventList = new ArrayList<>();
	ArrayList<Double> p2kDown = new ArrayList<>();
	ArrayList<Double> p2kUp = new ArrayList<>();
	ArrayList<Double> k2cDown = new ArrayList<>();
	ArrayList<Double> k2cUp = new ArrayList<>();

	private BroadcastReceiver logReceiver = new BroadcastReceiver() {
	@Override
	public void onReceive(Context context, Intent intent) {
	String msg = intent.getStringExtra("message");
	TapLatencyFragment.this.appendLogText(msg);
	}
	};

	private View.OnTouchListener touchListener = new View.OnTouchListener() {
	@Override
	public boolean onTouch(View v, MotionEvent event) {
	UsMotionEvent tapEvent = new UsMotionEvent(event, waltDevice.clock.baseTime);

	if(tapEvent.action != MotionEvent.ACTION_UP && tapEvent.action != MotionEvent.ACTION_DOWN) {
	moveCount++;
	updateCountsDisplay();
	return true;
	}

	// Debug: logger.log("\n"+ action + " event received: " + tapEvent.toStringLong());
	tapEvent.physicalTime = waltDevice.readLastShockTime();

	tapEvent.isOk = checkTapSanity(tapEvent);
	// Save it in any case so we can do stats on bad events later
	eventList.add(tapEvent);

	final double physicalToKernelTime = (tapEvent.kernelTime - tapEvent.physicalTime) / 1000.;
	final double kernelToCallbackTime = (tapEvent.createTime - tapEvent.kernelTime) / 1000.;
	if (tapEvent.action == MotionEvent.ACTION_DOWN) {
	allDownCount++;
	if (tapEvent.isOk) {
	okDownCount++;
	p2kDown.add(physicalToKernelTime);
	k2cDown.add(kernelToCallbackTime);
	if (shouldShowLatencyChart) latencyChart.addEntry(ACTION_DOWN_INDEX, physicalToKernelTime);
	logger.log(String.format(Locale.US,
	"ACTION_DOWN:\ntouch2kernel: %.1f ms\nkernel2java: %.1f ms",
	physicalToKernelTime, kernelToCallbackTime));
	}
	} else if (tapEvent.action == MotionEvent.ACTION_UP) {
	allUpCount++;
	if (tapEvent.isOk) {
	okUpCount++;
	p2kUp.add(physicalToKernelTime);
	k2cUp.add(kernelToCallbackTime);
	if (shouldShowLatencyChart) latencyChart.addEntry(ACTION_UP_INDEX, physicalToKernelTime);
	logger.log(String.format(Locale.US,
	"ACTION_UP:\ntouch2kernel: %.1f ms\nkernel2java: %.1f ms",
	physicalToKernelTime, kernelToCallbackTime));
	}
	}
	traceLogEvent(tapEvent);

	updateCountsDisplay();
	return true;
	}
	};

	private void traceLogEvent(UsMotionEvent tapEvent) {
	if (!tapEvent.isOk) return;
	if (traceLogger == null) return;
	if (tapEvent.action != MotionEvent.ACTION_DOWN && tapEvent.action != MotionEvent.ACTION_UP) return;
	final String title = tapEvent.action == MotionEvent.ACTION_UP ? "Tap-Up" : "Tap-Down";
	traceLogger.log(tapEvent.physicalTime + waltDevice.clock.baseTime,
	tapEvent.kernelTime + waltDevice.clock.baseTime, title + " Physical",
	"Bar starts at accelerometer shock and ends at kernel time of tap event");
	traceLogger.log(tapEvent.kernelTime + waltDevice.clock.baseTime,
	tapEvent.createTime + waltDevice.clock.baseTime, title + " App Callback",
	"Bar starts at kernel time of tap event and ends at app callback time");
	}

	public TapLatencyFragment() {
	// Required empty public constructor
	}

	@Override
	public View onCreateView(LayoutInflater inflater, ViewGroup container,
	Bundle savedInstanceState) {
	shouldShowLatencyChart = getBooleanPreference(getContext(), R.string.preference_show_tap_histogram, true);
	if (getBooleanPreference(getContext(), R.string.preference_systrace, true)) {
	traceLogger = TraceLogger.getInstance();
	}
	waltDevice = WaltDevice.getInstance(getContext());
	logger = SimpleLogger.getInstance(getContext());
	// Inflate the layout for this fragment
	final View view = inflater.inflate(R.layout.fragment_tap_latency, container, false);
	restartButton = (ImageButton) view.findViewById(R.id.button_restart_tap);
	finishButton = (ImageButton) view.findViewById(R.id.button_finish_tap);
	tapCatcherView = (TextView) view.findViewById(R.id.tap_catcher);
	logTextView = (TextView) view.findViewById(R.id.txt_log_tap_latency);
	tapCountsView = (TextView) view.findViewById(R.id.txt_tap_counts);
	moveCountsView = (TextView) view.findViewById(R.id.txt_move_count);
	latencyChart = (HistogramChart) view.findViewById(R.id.latency_chart);
	logTextView.setMovementMethod(new ScrollingMovementMethod());
	finishButton.setEnabled(false);
	return view;
	}

	@Override
	public void onResume() {
	super.onResume();

	logTextView.setText(logger.getLogText());
	logger.registerReceiver(logReceiver);

	// Register this fragment class as the listener for some button clicks
	restartButton.setOnClickListener(this);
	finishButton.setOnClickListener(this);
	}

	@Override
	public void onPause() {
	logger.unregisterReceiver(logReceiver);
	super.onPause();
	}

	public void appendLogText(String msg) {
	logTextView.append(msg + "\n");
	}

	public boolean checkTapSanity(UsMotionEvent e) {
	String action = e.getActionString();
	double dt = (e.kernelTime - e.physicalTime) / 1000.0;

	if (e.physicalTime == 0) {
	logger.log(action + " no shock found");
	return false;
	}

	if (dt < 0 \|\| dt > 200) {
	logger.log(action + " bogus kernelTime=" + e.kernelTime + ", ignored, dt=" + dt);
	return false;
	}
	return true;
	}

	void updateCountsDisplay() {
	String tpl = "N ↓%d (%d) ↑%d (%d)";
	tapCountsView.setText(String.format(Locale.US,
	tpl,
	okDownCount,
	allDownCount,
	okUpCount,
	allUpCount
	));

	moveCountsView.setText(String.format(Locale.US, "⇄ %d", moveCount));
	}

	void restartMeasurement() {
	logger.log("\n## Restarting tap latency measurement. Re-sync clocks ...");
	try {
	waltDevice.softReset();
	waltDevice.syncClock();
	} catch (IOException e) {
	logger.log("Error syncing clocks: " + e.getMessage());
	restartButton.setImageResource(R.drawable.ic_play_arrow_black_24dp);
	finishButton.setEnabled(false);
	latencyChart.setVisibility(View.GONE);
	return;
	}

	eventList.clear();
	p2kDown.clear();
	p2kUp.clear();
	k2cDown.clear();
	k2cUp.clear();

	moveCount = 0;
	allDownCount = 0;
	allUpCount = 0;
	okDownCount = 0;
	okUpCount = 0;

	updateCountsDisplay();
	tapCatcherView.setOnTouchListener(touchListener);
	}

	void finishAndShowStats() {
	tapCatcherView.setOnTouchListener(null);
	waltDevice.checkDrift();
	logger.log("\n-------------------------------");
	logger.log(String.format(Locale.US,
	"Tap latency results:\n" +
	"Number of events recorded:\n" +
	" ACTION_DOWN %d (bad %d)\n" +
	" ACTION_UP %d (bad %d)\n" +
	" ACTION_MOVE %d",
	okDownCount,
	allDownCount - okDownCount,
	okUpCount,
	allUpCount - okUpCount,
	moveCount
	));

	logger.log("ACTION_DOWN median times:");
	logger.log(String.format(Locale.US,
	" Touch to kernel: %.1f ms\n Kernel to Java: %.1f ms",
	Utils.median(p2kDown),
	Utils.median(k2cDown)
	));
	logger.log("ACTION_UP median times:");
	logger.log(String.format(Locale.US,
	" Touch to kernel: %.1f ms\n Kernel to Java: %.1f ms",
	Utils.median(p2kUp),
	Utils.median(k2cUp)
	));
	logger.log("-------------------------------");
	if (traceLogger != null) traceLogger.flush(getContext());

	if (shouldShowLatencyChart) {
	latencyChart.setLabel(ACTION_DOWN_INDEX, String.format(Locale.US, "ACTION_DOWN median=%.1f ms", Utils.median(p2kDown)));
	latencyChart.setLabel(ACTION_UP_INDEX, String.format(Locale.US, "ACTION_UP median=%.1f ms", Utils.median(p2kUp)));
	}
	LogUploader.uploadIfAutoEnabled(getContext());
	}

	@Override
	public void onClick(View v) {
	if (v.getId() == R.id.button_restart_tap) {
	restartButton.setImageResource(R.drawable.ic_refresh_black_24dp);
	finishButton.setEnabled(true);
	if (shouldShowLatencyChart) {
	latencyChart.setVisibility(View.VISIBLE);
	latencyChart.clearData();
	latencyChart.setLabel(ACTION_DOWN_INDEX, "ACTION_DOWN");
	latencyChart.setLabel(ACTION_UP_INDEX, "ACTION_UP");
	}
	restartMeasurement();
	return;
	}

	if (v.getId() == R.id.button_finish_tap) {
	finishButton.setEnabled(false);
	finishAndShowStats();
	restartButton.setImageResource(R.drawable.ic_play_arrow_black_24dp);
	return;
	}

	}

	public void onRobotAutomationEvent(String event) {
	// Never show the latency chart during automated runs.
	shouldShowLatencyChart = false;
	if (event.equals(RobotAutomationListener.RESTART_EVENT) \|\|
	event.equals(RobotAutomationListener.START_EVENT)) {
	restartMeasurement();
	} else if (event.equals(RobotAutomationListener.FINISH_EVENT)) {
	finishAndShowStats();
	}
	}
	}