forked from upstream-mirrors/OpenTracks
youtaol
711 lines
24 KiB
Java
711 lines
24 KiB
Java
/*
|
|
* Copyright 2012 Google Inc.
|
|
*
|
|
* 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.google.android.apps.mytracks.smoketest;
|
|
|
|
import com.google.android.apps.mytracks.TrackListActivity;
|
|
import com.google.android.apps.mytracks.fragments.MapFragment;
|
|
import com.google.android.apps.mytracks.util.FileUtils;
|
|
import com.google.android.maps.MapView;
|
|
import com.google.android.maps.mytracks.R;
|
|
import com.jayway.android.robotium.solo.Solo;
|
|
|
|
import android.app.Activity;
|
|
import android.app.Instrumentation;
|
|
import android.test.ActivityInstrumentationTestCase2;
|
|
import android.view.KeyEvent;
|
|
import android.view.View;
|
|
import android.widget.Button;
|
|
import android.widget.CheckBox;
|
|
import android.widget.ListView;
|
|
|
|
import java.io.File;
|
|
import java.io.FileFilter;
|
|
import java.util.ArrayList;
|
|
|
|
/**
|
|
* Makes a smoke test of MyTracks. It's a total end-to-end test.
|
|
*
|
|
* @author Youtao Liu
|
|
*/
|
|
public class MyTracksSmokeTest extends ActivityInstrumentationTestCase2<TrackListActivity> {
|
|
|
|
private static final String TRACK_NAME_PREFIX = "testTrackName";
|
|
private static final String WAYPOINT_NAME = "testWaypoint";
|
|
private static final String STATISTICS_NAME = "testStatistics";
|
|
private static final String GPX = "gpx";
|
|
private static final String KML = "kml";
|
|
private static final String CSV = "csv";
|
|
private static final String TCX = "tcx";
|
|
private static final String MENU_MORE = "More";
|
|
|
|
private Instrumentation instrumentation;
|
|
private TrackListActivity activityMyTracks;
|
|
private Solo solo;
|
|
private boolean checkedFirstLaunch = false;
|
|
// Check whether the UI has an action bar which is related with the version of
|
|
// Android OS.
|
|
private boolean hasActionBar = false;
|
|
private String trackName;
|
|
|
|
public MyTracksSmokeTest() {
|
|
super(TrackListActivity.class);
|
|
}
|
|
|
|
@Override
|
|
protected void setUp() throws Exception {
|
|
super.setUp();
|
|
instrumentation = getInstrumentation();
|
|
activityMyTracks = getActivity();
|
|
solo = new Solo(instrumentation, activityMyTracks);
|
|
// Checks if open MyTracks first time after install. If so, there would be a
|
|
// welcome view with accept buttons. And makes sure only check once.
|
|
if (!checkedFirstLaunch) {
|
|
if ((getButtonOnScreen(activityMyTracks.getString(R.string.eula_accept)) != null)) {
|
|
verifyFirstLaunch();
|
|
}
|
|
setHasActionBar();
|
|
checkedFirstLaunch = true;
|
|
}
|
|
|
|
// Makes every track name is unique to make sure every check can be trusted.
|
|
trackName = TRACK_NAME_PREFIX + System.currentTimeMillis();
|
|
}
|
|
|
|
/**
|
|
* Switches view from {@link MapFragment} to @ ChartFragment} , then changes
|
|
* to @ StatsFragment} . Finally back to {@link MapFragment}. And check some
|
|
* menus in these views.
|
|
*/
|
|
public void testSwitchViewsAndMenusOfView() {
|
|
createSimpleTrack(3);
|
|
|
|
solo.goBack();
|
|
solo.clickOnText(trackName);
|
|
|
|
solo.clickOnText(activityMyTracks.getString(R.string.track_detail_chart_tab));
|
|
rotateAllActivities();
|
|
sendKeys(KeyEvent.KEYCODE_MENU);
|
|
findMenuItem(activityMyTracks.getString(R.string.menu_chart_settings), true);
|
|
assertTrue(solo.searchText(activityMyTracks.getString(R.string.chart_settings_by_distance)));
|
|
solo.goBack();
|
|
|
|
solo.clickOnText(activityMyTracks.getString(R.string.track_detail_stats_tab));
|
|
sendKeys(KeyEvent.KEYCODE_MENU);
|
|
findMenuItem(activityMyTracks.getString(R.string.menu_satellite_mode), false);
|
|
findMenuItem(activityMyTracks.getString(R.string.menu_sensor_state), true);
|
|
assertTrue(solo.searchText(activityMyTracks.getString(R.string.sensor_state_last_sensor_time)));
|
|
solo.goBack();
|
|
|
|
solo.clickOnText(activityMyTracks.getString(R.string.track_detail_map_tab));
|
|
sendKeys(KeyEvent.KEYCODE_MENU);
|
|
assertTrue(findMenuItem(activityMyTracks.getString(R.string.menu_my_location), false));
|
|
}
|
|
|
|
/**
|
|
* Creates a track with markers and the setting to send to google.
|
|
*/
|
|
public void testCreateAndSendTrack() {
|
|
// Create a track at first.
|
|
createSimpleTrack(1);
|
|
instrumentation.waitForIdleSync();
|
|
sendKeys(KeyEvent.KEYCODE_MENU);
|
|
findMenuItem(activityMyTracks.getString(R.string.menu_send_google), true);
|
|
solo.waitForText(activityMyTracks.getString(R.string.send_google_title));
|
|
rotateCurrentActivity();
|
|
|
|
ArrayList<CheckBox> checkBoxs = solo.getCurrentCheckBoxes();
|
|
for (int i = 0; i < checkBoxs.size(); i++) {
|
|
if (checkBoxs.get(i).isChecked()) {
|
|
solo.clickOnCheckBox(i);
|
|
}
|
|
}
|
|
instrumentation.waitForIdleSync();
|
|
solo.clickOnText(activityMyTracks.getString(R.string.send_google_send_now));
|
|
assertTrue(solo.waitForText(activityMyTracks
|
|
.getString(R.string.send_google_no_service_selected)));
|
|
// Stop here for do not really send.
|
|
}
|
|
|
|
/**
|
|
* Tests saving a track to SD card as a GPX file.
|
|
*/
|
|
public void testSaveToSDCard_GPX() {
|
|
createSimpleTrack(0);
|
|
saveTrackToSdCard(GPX);
|
|
}
|
|
|
|
/**
|
|
* Tests saving a track to SD card as a KML file.
|
|
*/
|
|
public void testSaveToSDCard_KML() {
|
|
createSimpleTrack(0);
|
|
saveTrackToSdCard(KML);
|
|
}
|
|
|
|
/**
|
|
* Tests saving a track to SD card as a CSV file.
|
|
*/
|
|
public void testSaveToSDCard_CSV() {
|
|
createSimpleTrack(0);
|
|
saveTrackToSdCard(CSV);
|
|
}
|
|
|
|
/**
|
|
* Tests saving a track to SD card as a TCX file.
|
|
*/
|
|
public void testSaveToSDCard_TCX() {
|
|
createSimpleTrack(0);
|
|
saveTrackToSdCard(TCX);
|
|
}
|
|
|
|
/**
|
|
* Tests editing a track.
|
|
*/
|
|
public void testEditTrack() {
|
|
createSimpleTrack(0);
|
|
instrumentation.waitForIdleSync();
|
|
sendKeys(KeyEvent.KEYCODE_MENU);
|
|
findMenuItem(activityMyTracks.getString(R.string.menu_edit), true);
|
|
|
|
String newTrackName = TRACK_NAME_PREFIX + "_new" + System.currentTimeMillis();
|
|
String newType = "type" + newTrackName;
|
|
String newDesc = "desc" + newTrackName;
|
|
|
|
instrumentation.waitForIdleSync();
|
|
rotateAllActivities();
|
|
sendKeys(KeyEvent.KEYCODE_DEL);
|
|
solo.enterText(0, newTrackName);
|
|
sendKeys(KeyEvent.KEYCODE_TAB);
|
|
solo.enterText(1, newType);
|
|
sendKeys(KeyEvent.KEYCODE_TAB);
|
|
solo.enterText(2, newDesc);
|
|
|
|
solo.clickOnButton(activityMyTracks.getString(R.string.generic_save));
|
|
instrumentation.waitForIdleSync();
|
|
// Goes back to track list.
|
|
solo.goBack();
|
|
|
|
assertTrue(solo.searchText(newTrackName));
|
|
assertTrue(solo.searchText(newDesc));
|
|
}
|
|
|
|
/**
|
|
* Tests the menu My Location.
|
|
*/
|
|
public void testGotoMyLocation() {
|
|
createSimpleTrack(1);
|
|
solo.sendKey(KeyEvent.KEYCODE_MENU);
|
|
findMenuItem(activityMyTracks.getString(R.string.menu_my_location), true);
|
|
// TODO How to verify the location is shown on the map.
|
|
}
|
|
|
|
/**
|
|
* Changes some settings and then reset them.
|
|
*/
|
|
public void testSetting() {
|
|
sendKeys(KeyEvent.KEYCODE_MENU);
|
|
findMenuItem(activityMyTracks.getString(R.string.menu_settings), true);
|
|
instrumentation.waitForIdleSync();
|
|
// Rotates on the settings page.
|
|
rotateAllActivities();
|
|
solo.waitForText(activityMyTracks.getString(R.string.settings_reset));
|
|
// Resets all settings at first.
|
|
solo.clickOnText(activityMyTracks.getString(R.string.settings_reset));
|
|
solo.clickOnButton(activityMyTracks.getString(R.string.generic_ok));
|
|
// Changes a setting of display.
|
|
solo.clickOnText(activityMyTracks.getString(R.string.settings_display));
|
|
solo.waitForText(activityMyTracks.getString(R.string.settings_display_metric));
|
|
// Rotates on a sub setting page.
|
|
rotateAllActivities();
|
|
solo.waitForText(activityMyTracks.getString(R.string.settings_display_metric));
|
|
ArrayList<CheckBox> displayCheckBoxs = solo.getCurrentCheckBoxes();
|
|
boolean useMetric = displayCheckBoxs.get(0).isChecked();
|
|
solo.clickOnCheckBox(0);
|
|
solo.goBack();
|
|
// Changes a setting of sharing.
|
|
solo.clickOnText(activityMyTracks.getString(R.string.settings_sharing));
|
|
solo.waitForText(activityMyTracks.getString(R.string.settings_sharing_allow_access));
|
|
ArrayList<CheckBox> sharingCheckBoxs = solo.getCurrentCheckBoxes();
|
|
boolean newMapsPublic = sharingCheckBoxs.get(0).isChecked();
|
|
solo.clickOnCheckBox(0);
|
|
// Rotates on a sub setting page when the value of a checkbox is changed.
|
|
instrumentation.waitForIdleSync();
|
|
rotateAllActivities();
|
|
solo.waitForText(activityMyTracks.getString(R.string.settings_sharing_allow_access));
|
|
assertEquals(!newMapsPublic, sharingCheckBoxs.get(0).isChecked());
|
|
solo.goBack();
|
|
|
|
// Resets all settings.
|
|
solo.clickOnText(activityMyTracks.getString(R.string.settings_reset));
|
|
solo.clickOnButton(activityMyTracks.getString(R.string.generic_ok));
|
|
|
|
// Checks settings.
|
|
solo.clickOnText(activityMyTracks.getString(R.string.settings_display));
|
|
solo.waitForText(activityMyTracks.getString(R.string.settings_display_metric));
|
|
displayCheckBoxs = solo.getCurrentCheckBoxes();
|
|
assertEquals(useMetric, displayCheckBoxs.get(0).isChecked());
|
|
|
|
solo.goBack();
|
|
solo.clickOnText(activityMyTracks.getString(R.string.settings_sharing));
|
|
solo.waitForText(activityMyTracks.getString(R.string.settings_sharing_allow_access));
|
|
sharingCheckBoxs = solo.getCurrentCheckBoxes();
|
|
assertEquals(newMapsPublic, sharingCheckBoxs.get(0).isChecked());
|
|
}
|
|
|
|
/**
|
|
* Creates one track with a two locations, a way point and a statistics point.
|
|
*/
|
|
public void testCreateTrackWithMarkers() {
|
|
solo.sendKey(KeyEvent.KEYCODE_MENU);
|
|
findMenuItem(activityMyTracks.getString(R.string.menu_delete_all), true);
|
|
solo.clickOnButton(activityMyTracks.getString(R.string.generic_ok));
|
|
instrumentation.waitForIdleSync();
|
|
|
|
startRecording();
|
|
instrumentation.waitForIdleSync();
|
|
SmokeTestUtils.sendGps(2);
|
|
createWaypointAndStatistics();
|
|
SmokeTestUtils.sendGps(2);
|
|
// Backs to tracks list.
|
|
solo.goBack();
|
|
instrumentation.waitForIdleSync();
|
|
rotateAllActivities();
|
|
stopRecording(false);
|
|
solo.enterText(0, trackName);
|
|
solo.clickOnButton(activityMyTracks.getString(R.string.generic_save));
|
|
|
|
instrumentation.waitForIdleSync();
|
|
// Checks the new track
|
|
assertTrue(solo.waitForText(trackName, 1, 5000, true, false));
|
|
}
|
|
|
|
/**
|
|
* Deletes all tracks.
|
|
*/
|
|
public void testDeleteTracks() {
|
|
createSimpleTrack(0);
|
|
solo.goBack();
|
|
instrumentation.waitForIdleSync();
|
|
// There is at least one track.
|
|
ArrayList<ListView> trackListView = solo.getCurrentListViews();
|
|
assertTrue(trackListView.size() > 0);
|
|
assertTrue(trackListView.get(0).getCount() > 0);
|
|
|
|
solo.sendKey(KeyEvent.KEYCODE_MENU);
|
|
findMenuItem(activityMyTracks.getString(R.string.menu_delete_all), true);
|
|
instrumentation.waitForIdleSync();
|
|
rotateAllActivities();
|
|
solo.clickOnButton(activityMyTracks.getString(R.string.generic_ok));
|
|
instrumentation.waitForIdleSync();
|
|
// There is no track now.
|
|
trackListView = solo.getCurrentListViews();
|
|
assertEquals(0, trackListView.get(0).getCount());
|
|
}
|
|
|
|
/**
|
|
* Tests export and import tracks.
|
|
* <ul>
|
|
* <li>Create two tracks, one of them is empty(Have no Gps data).</li>
|
|
* <li>Tests import when there is no track file.</li>
|
|
* <li>Tests export tracks to Gpx files.</li>
|
|
* <li>Tests import files to tracks.</li>
|
|
* <li>Tests export tracks to Kml files.</li>
|
|
* </ul>
|
|
*/
|
|
public void testExportAndImportTracks() {
|
|
// Creates a new track with 3 gps data.
|
|
createSimpleTrack(3);
|
|
solo.goBack();
|
|
instrumentation.waitForIdleSync();
|
|
// Creates a empty track.
|
|
createSimpleTrack(0);
|
|
solo.goBack();
|
|
instrumentation.waitForIdleSync();
|
|
// Deletes all exported gpx and kml tracks.
|
|
deleteExportedFiles(GPX);
|
|
deleteExportedFiles(KML);
|
|
int gpxFilesNumber = 0;
|
|
File[] allGpxFiles = getExportedFiles(GPX);
|
|
// For the first export, there is no MyTracks folder.
|
|
if (allGpxFiles != null) {
|
|
gpxFilesNumber = getExportedFiles(GPX).length;
|
|
}
|
|
|
|
// Gets track number in current track list of MyTracks.
|
|
int trackNumber = solo.getCurrentListViews().get(0).getCount();
|
|
|
|
// No file to imported.
|
|
sendKeys(KeyEvent.KEYCODE_MENU);
|
|
findMenuItem(activityMyTracks.getString(R.string.menu_import_all), true);
|
|
solo.waitForText(activityMyTracks.getString(R.string.import_no_file,
|
|
FileUtils.buildExternalDirectoryPath(GPX)));
|
|
solo.clickOnButton(activityMyTracks.getString(R.string.generic_ok));
|
|
|
|
// Clicks to export tracks(At least one track) to Gpx files.
|
|
sendKeys(KeyEvent.KEYCODE_MENU);
|
|
findMenuItem(activityMyTracks.getString(R.string.menu_export_all), true);
|
|
solo.clickOnText(String.format(activityMyTracks.getString(R.string.menu_export_all_format),
|
|
GPX.toUpperCase()));
|
|
rotateAllActivities();
|
|
solo.waitForText(activityMyTracks.getString(R.string.export_success));
|
|
// Checks export file.
|
|
assertEquals(gpxFilesNumber + trackNumber, getExportedFiles(GPX).length);
|
|
instrumentation.waitForIdleSync();
|
|
|
|
// Clicks to import track.
|
|
gpxFilesNumber = getExportedFiles(GPX).length;
|
|
trackNumber = solo.getCurrentListViews().get(0).getCount();
|
|
|
|
sendKeys(KeyEvent.KEYCODE_MENU);
|
|
findMenuItem(activityMyTracks.getString(R.string.menu_import_all), true);
|
|
rotateAllActivities();
|
|
// Waits for the prefix of import success string is much faster than wait
|
|
// the whole string.
|
|
solo.waitForText(activityMyTracks.getString(R.string.import_success).split("%")[0]);
|
|
// Checks import tracks should be equal with the sum of trackNumber and
|
|
// gpxFilesNumber;
|
|
solo.clickOnText(activityMyTracks.getString(R.string.generic_ok));
|
|
instrumentation.waitForIdleSync();
|
|
assertEquals(trackNumber + gpxFilesNumber, solo.getCurrentListViews().get(0).getCount());
|
|
|
|
// Clicks to export tracks(At least two tracks) to KML files.
|
|
gpxFilesNumber = getExportedFiles(GPX).length;
|
|
trackNumber = solo.getCurrentListViews().get(0).getCount();
|
|
sendKeys(KeyEvent.KEYCODE_MENU);
|
|
findMenuItem(activityMyTracks.getString(R.string.menu_export_all), true);
|
|
solo.clickOnText(String.format(activityMyTracks.getString(R.string.menu_export_all_format),
|
|
KML.toUpperCase()));
|
|
solo.waitForText(activityMyTracks.getString(R.string.export_success));
|
|
// Checks export file.
|
|
assertEquals(gpxFilesNumber, getExportedFiles(GPX).length);
|
|
assertEquals(trackNumber, getExportedFiles(KML).length);
|
|
}
|
|
|
|
/**
|
|
* Tests the switch between satellite mode and map mode.
|
|
*/
|
|
public void testSatelliteAndMapView() {
|
|
startRecording();
|
|
instrumentation.waitForIdleSync();
|
|
// Check current mode.
|
|
boolean isMapMode = true;
|
|
sendKeys(KeyEvent.KEYCODE_MENU);
|
|
// If can not find switch menu in top menu, click More menu.
|
|
if (!findMenuItem(activityMyTracks.getString(R.string.menu_satellite_mode), false)) {
|
|
isMapMode = false;
|
|
}
|
|
// Switches to satellite mode if it's map mode now..
|
|
solo.clickOnText(activityMyTracks.getString(isMapMode ? R.string.menu_satellite_mode
|
|
: R.string.menu_map_mode));
|
|
|
|
isMapMode = !isMapMode;
|
|
|
|
ArrayList<View> allViews = solo.getViews();
|
|
for (View view : allViews) {
|
|
if (view instanceof MapView) {
|
|
assertEquals(isMapMode, !(((MapView) view).isSatellite()));
|
|
}
|
|
}
|
|
instrumentation.waitForIdleSync();
|
|
|
|
solo.sendKey(KeyEvent.KEYCODE_MENU);
|
|
findMenuItem(activityMyTracks.getString(R.string.menu_help), false);
|
|
instrumentation.waitForIdleSync();
|
|
rotateAllActivities();
|
|
|
|
// Switches back.
|
|
solo.clickOnText(activityMyTracks.getString(isMapMode ? R.string.menu_satellite_mode
|
|
: R.string.menu_map_mode));
|
|
isMapMode = !isMapMode;
|
|
allViews = solo.getViews();
|
|
for (View view : allViews) {
|
|
if (view instanceof MapView) {
|
|
assertEquals(isMapMode, !(((MapView) view).isSatellite()));
|
|
}
|
|
}
|
|
|
|
// Waits for the TrackDetailActivity, or the stop button will can not be
|
|
// found in next step.
|
|
solo.waitForText(activityMyTracks.getString(R.string.track_detail_chart_tab), 0, 1000);
|
|
stopRecording(true);
|
|
}
|
|
|
|
/**
|
|
* Tests following items in More menu.
|
|
* <ul>
|
|
* <li>Tests the aggregated statistics activity.</li>
|
|
* <li>Tests the Sensor state activity.</li>
|
|
* <li>Tests the help menu.</li>
|
|
* </ul>
|
|
*/
|
|
public void testSomeMenuItems() {
|
|
// Menu in TrackListActivity.
|
|
sendKeys(KeyEvent.KEYCODE_MENU);
|
|
findMenuItem(activityMyTracks.getString(R.string.menu_aggregated_statistics), true);
|
|
solo.waitForText(activityMyTracks.getString(R.string.stat_total_distance));
|
|
solo.goBack();
|
|
|
|
startRecording();
|
|
instrumentation.waitForIdleSync();
|
|
// Menu in TrackDetailActivity.
|
|
sendKeys(KeyEvent.KEYCODE_MENU);
|
|
findMenuItem(activityMyTracks.getString(R.string.menu_sensor_state), true);
|
|
solo.waitForText(activityMyTracks.getString(R.string.sensor_state_last_sensor_time));
|
|
|
|
solo.goBack();
|
|
sendKeys(KeyEvent.KEYCODE_MENU);
|
|
findMenuItem(activityMyTracks.getString(R.string.menu_help), true);
|
|
solo.clickOnText(activityMyTracks.getString(R.string.help_about));
|
|
solo.clickOnText(activityMyTracks.getString(R.string.generic_ok));
|
|
solo.clickOnText(activityMyTracks.getString(R.string.generic_ok));
|
|
|
|
stopRecording(true);
|
|
}
|
|
|
|
/**
|
|
* Creates a way point and a statistics during track recording.
|
|
*/
|
|
private void createWaypointAndStatistics() {
|
|
sendKeys(KeyEvent.KEYCODE_MENU);
|
|
findMenuItem(activityMyTracks.getString(R.string.menu_markers), true);
|
|
|
|
solo.clickOnButton(activityMyTracks.getString(R.string.marker_list_insert_waypoint));
|
|
solo.clickOnText(activityMyTracks.getString(R.string.marker_detail_marker_name));
|
|
instrumentation.waitForIdleSync();
|
|
rotateAllActivities();
|
|
solo.enterText(0, WAYPOINT_NAME);
|
|
|
|
solo.clickOnButton(activityMyTracks.getString(R.string.generic_save));
|
|
|
|
solo.clickOnButton(activityMyTracks.getString(R.string.marker_list_insert_statistics));
|
|
solo.clickOnText(activityMyTracks.getString(R.string.marker_detail_marker_name));
|
|
solo.enterText(0, STATISTICS_NAME);
|
|
solo.clickOnButton(activityMyTracks.getString(R.string.generic_save));
|
|
|
|
assertTrue(solo.searchText(WAYPOINT_NAME));
|
|
assertTrue(solo.searchText(STATISTICS_NAME));
|
|
|
|
solo.goBack();
|
|
}
|
|
|
|
@Override
|
|
protected void tearDown() throws Exception {
|
|
solo.finishOpenedActivities();
|
|
super.tearDown();
|
|
}
|
|
|
|
/**
|
|
* Accepts terms and configures units.
|
|
*/
|
|
private void verifyFirstLaunch() {
|
|
solo.clickOnText(activityMyTracks.getString(R.string.eula_accept));
|
|
// Clicks for welcome.
|
|
solo.clickOnText(activityMyTracks.getString(R.string.generic_ok));
|
|
// Clicks for choose units.
|
|
solo.clickOnText(activityMyTracks.getString(R.string.generic_ok));
|
|
instrumentation.waitForIdleSync();
|
|
}
|
|
|
|
/**
|
|
* Creates a simple track which can be used by subsequent test.
|
|
*
|
|
* @param numberOfGpsData number of simulated Gps data
|
|
*/
|
|
private void createSimpleTrack(int numberOfGpsData) {
|
|
startRecording();
|
|
SmokeTestUtils.sendGps(numberOfGpsData);
|
|
stopRecording(true);
|
|
}
|
|
|
|
/**
|
|
* Starts recoding track.
|
|
*/
|
|
private void startRecording() {
|
|
if (hasActionBar) {
|
|
Button startButton =
|
|
getButtonOnScreen(activityMyTracks.getString(R.string.menu_record_track));
|
|
// In case a track is recording.
|
|
if (startButton == null) {
|
|
stopRecording(true);
|
|
startButton = getButtonOnScreen(activityMyTracks.getString(R.string.menu_record_track));
|
|
}
|
|
solo.clickOnView(startButton);
|
|
} else {
|
|
sendKeys(KeyEvent.KEYCODE_MENU);
|
|
if (!solo.searchText(activityMyTracks.getString(R.string.menu_record_track))) {
|
|
// Check if in TrackDetailActivity.
|
|
if (solo.searchText(activityMyTracks.getString(R.string.menu_play))) {
|
|
solo.goBack();
|
|
} else {
|
|
// In case a track is recording.
|
|
stopRecording(true);
|
|
sendKeys(KeyEvent.KEYCODE_MENU);
|
|
}
|
|
}
|
|
instrumentation.waitForIdleSync();
|
|
solo.clickOnText(activityMyTracks.getString(R.string.menu_record_track));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Stops recoding track.
|
|
*
|
|
* @param isSave ture means should save this track
|
|
*/
|
|
private void stopRecording(boolean isSave) {
|
|
instrumentation.waitForIdleSync();
|
|
if (hasActionBar) {
|
|
solo.clickOnView(getButtonOnScreen(activityMyTracks.getString(R.string.menu_stop_recording)));
|
|
} else {
|
|
sendKeys(KeyEvent.KEYCODE_MENU);
|
|
solo.clickOnText(activityMyTracks.getString(R.string.menu_stop_recording));
|
|
}
|
|
if (isSave) {
|
|
instrumentation.waitForIdleSync();
|
|
solo.enterText(0, trackName);
|
|
solo.clickLongOnText(activityMyTracks.getString(R.string.generic_save));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Deletes a kind of track in MyTracks folder.
|
|
*
|
|
* @param trackKind the kind of track
|
|
*/
|
|
private void deleteExportedFiles(String trackKind) {
|
|
File[] allFiles =
|
|
(new File(FileUtils.buildExternalDirectoryPath(trackKind.toLowerCase()))).listFiles();
|
|
if (allFiles != null) {
|
|
for (File oneFile : allFiles) {
|
|
oneFile.delete();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets a kind of exported files.
|
|
*
|
|
* @param trackKind the kind of track
|
|
* @return files array of such kind of exported tracks
|
|
*/
|
|
private File[] getExportedFiles(final String trackKind) {
|
|
String filePath = FileUtils.buildExternalDirectoryPath(trackKind);
|
|
FileFilter filter = new FileFilter() {
|
|
@Override
|
|
public boolean accept(File pathname) {
|
|
return pathname.getName().indexOf("." + trackKind) > 0;
|
|
}
|
|
};
|
|
return (new File(filePath)).listFiles(filter);
|
|
}
|
|
|
|
/**
|
|
* Saves a track to a kind of file in SD card.
|
|
*
|
|
* @param trackKind the kind of track
|
|
*/
|
|
private void saveTrackToSdCard(String trackKind) {
|
|
deleteExportedFiles(trackKind);
|
|
instrumentation.waitForIdleSync();
|
|
sendKeys(KeyEvent.KEYCODE_MENU);
|
|
instrumentation.waitForIdleSync();
|
|
solo.clickOnText(activityMyTracks.getString(R.string.menu_save));
|
|
solo.clickOnText(trackKind.toUpperCase());
|
|
rotateAllActivities();
|
|
solo.waitForText(activityMyTracks.getString(R.string.generic_success_title));
|
|
assertEquals(1, getExportedFiles(trackKind).length);
|
|
}
|
|
|
|
/**
|
|
* Checks if a button is existed in the screen.
|
|
*
|
|
* @param buttonName the name string of the button
|
|
* @return the button to search, and null means can not find the button
|
|
*/
|
|
private Button getButtonOnScreen(String buttonName) {
|
|
ArrayList<Button> currentButtons = solo.getCurrentButtons();
|
|
for (Button button : currentButtons) {
|
|
if (((String) button.getText()).equalsIgnoreCase(buttonName)) {
|
|
return button;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Checks whether an action bar is shown.
|
|
*/
|
|
private void setHasActionBar() {
|
|
// If can find record button without pressing Menu, it should be an action
|
|
// bar.
|
|
Button startButton = getButtonOnScreen(activityMyTracks.getString(R.string.menu_record_track));
|
|
Button stopButton = getButtonOnScreen(activityMyTracks.getString(R.string.menu_stop_recording));
|
|
if (startButton != null || stopButton != null) {
|
|
hasActionBar = true;
|
|
} else {
|
|
sendKeys(KeyEvent.KEYCODE_MENU);
|
|
if (solo.searchText(activityMyTracks.getString(R.string.menu_record_track))
|
|
|| solo.searchText(activityMyTracks.getString(R.string.menu_stop_recording))) {
|
|
hasActionBar = false;
|
|
} else {
|
|
fail();
|
|
}
|
|
solo.goBack();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Rotates the current activity.
|
|
*/
|
|
private void rotateCurrentActivity() {
|
|
SmokeTestUtils.rotateActivity(solo.getCurrentActivity());
|
|
instrumentation.waitForIdleSync();
|
|
}
|
|
|
|
/**
|
|
* Rotates the all activities.
|
|
*/
|
|
private void rotateAllActivities() {
|
|
ArrayList<Activity> allActivities = solo.getAllOpenedActivities();
|
|
for (Activity activity : allActivities) {
|
|
SmokeTestUtils.rotateActivity(activity);
|
|
}
|
|
|
|
instrumentation.waitForIdleSync();
|
|
}
|
|
|
|
/**
|
|
* Finds an item in the menu with the option to click the item.
|
|
*
|
|
* @param menuName the name of item
|
|
* @param click true means need click this menu
|
|
* @return true if find this menu
|
|
*/
|
|
private boolean findMenuItem(String menuName, boolean click) {
|
|
boolean findResult = false;
|
|
if (solo.searchText(menuName)) {
|
|
findResult = true;
|
|
} else if (solo.searchText(MENU_MORE)) {
|
|
solo.clickOnText(MENU_MORE);
|
|
findResult = solo.searchText(menuName);
|
|
}
|
|
if (findResult && click) {
|
|
solo.clickOnText(menuName);
|
|
}
|
|
return findResult;
|
|
}
|
|
}
|