io.appium.java_client.android.AndroidMobileCommandHelper Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of java-client Show documentation
Show all versions of java-client Show documentation
Java client for Appium Mobile Webdriver
/*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* See the NOTICE file distributed with this work for additional
* information regarding copyright ownership.
* 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 io.appium.java_client.android;
import static com.google.common.base.Preconditions.checkArgument;
import com.google.common.collect.ImmutableMap;
import io.appium.java_client.MobileCommand;
import org.apache.commons.lang3.StringUtils;
import org.openqa.selenium.internal.HasIdentity;
import java.util.AbstractMap;
import java.util.Map;
/**
* This util class helps to prepare parameters of Android-specific JSONWP
* commands.
*/
public class AndroidMobileCommandHelper extends MobileCommand {
/**
* This method forms a {@link java.util.Map} of parameters for the
* getting of the current activity.
*
* @return a key-value pair. The key is the command name. The value is a
* {@link java.util.Map} command arguments.
*/
public static Map.Entry> currentActivityCommand() {
return new AbstractMap.SimpleEntry>(CURRENT_ACTIVITY, ImmutableMap.of());
}
/**
* This method forms a {@link java.util.Map} of parameters for the
* ending of the test coverage.
*
* @param intent intent to broadcast.
* @param path path to .ec file.
* @return a key-value pair. The key is the command name. The value is a
* {@link java.util.Map} command arguments.
*/
public static Map.Entry> endTestCoverageCommand(String intent,
String path) {
String[] parameters = new String[] {"intent", "path"};
Object[] values = new Object[] {intent, path};
return new AbstractMap.SimpleEntry>(END_TEST_COVERAGE, prepareArguments(parameters, values));
}
/**
* This method forms a {@link java.util.Map} of parameters for the
* getting of a network connection value.
*
* @return a key-value pair. The key is the command name. The value is a
* {@link java.util.Map} command arguments.
*/
public static Map.Entry> getNetworkConnectionCommand() {
return new AbstractMap.SimpleEntry>(GET_NETWORK_CONNECTION, ImmutableMap.of());
}
/**
* This method forms a {@link java.util.Map} of parameters for the
* checking of the device state (is it locked or not).
*
* @return a key-value pair. The key is the command name. The value is a
* {@link java.util.Map} command arguments.
*/
public static Map.Entry> isLockedCommand() {
return new AbstractMap.SimpleEntry>(IS_LOCKED, ImmutableMap.of());
}
/**
* This method forms a {@link java.util.Map} of parameters for the
* key event invocation.
*
* @param key code for the key pressed on the device.
* @return a key-value pair. The key is the command name. The value is a
* {@link java.util.Map} command arguments.
*/
public static Map.Entry> pressKeyCodeCommand(int key) {
return new AbstractMap.SimpleEntry>(PRESS_KEY_CODE, prepareArguments("keycode", key));
}
/**
* This method forms a {@link java.util.Map} of parameters for the
* key event invocation.
*
* @param key code for the key pressed on the Android device.
* @param metastate metastate for the keypress.
* @return a key-value pair. The key is the command name. The value is a
* {@link java.util.Map} command arguments.
*/
public static Map.Entry> pressKeyCodeCommand(int key,
Integer metastate) {
String[] parameters = new String[] {"keycode", "metastate"};
Object[] values = new Object[] {key, metastate};
return new AbstractMap.SimpleEntry>(PRESS_KEY_CODE, prepareArguments(parameters, values));
}
/**
* This method forms a {@link java.util.Map} of parameters for the
* long key event invocation.
*
* @param key code for the long key pressed on the device.
* @return a key-value pair. The key is the command name. The value is a
* {@link java.util.Map} command arguments.
*/
public static Map.Entry> longPressKeyCodeCommand(int key) {
return new AbstractMap.SimpleEntry>(LONG_PRESS_KEY_CODE, prepareArguments("keycode", key));
}
/**
* This method forms a {@link java.util.Map} of parameters for the
* long key event invocation.
*
* @param key code for the long key pressed on the Android device.
* @param metastate metastate for the long key press.
* @return a key-value pair. The key is the command name. The value is a
* {@link java.util.Map} command arguments.
*/
public static Map.Entry> longPressKeyCodeCommand(int key,
Integer metastate) {
String[] parameters = new String[] {"keycode", "metastate"};
Object[] values = new Object[] {key, metastate};
return new AbstractMap.SimpleEntry>(LONG_PRESS_KEY_CODE, prepareArguments(parameters, values));
}
/**
* This method forms a {@link java.util.Map} of parameters for the
* notification opening.
*
* @return a key-value pair. The key is the command name. The value is a
* {@link java.util.Map} command arguments.
*/
public static Map.Entry> openNotificationsCommand() {
return new AbstractMap.SimpleEntry>(OPEN_NOTIFICATIONS, ImmutableMap.of());
}
/**
* This method forms a {@link java.util.Map} of parameters for the
* file pushing
*
* @param remotePath Path to file to write data to on remote device
* @param base64Data Base64 encoded byte array of data to write to remote device
* @return a key-value pair. The key is the command name. The value is a
* {@link java.util.Map} command arguments.
*/
public static Map.Entry> pushFileCommandCommand(String remotePath,
byte[] base64Data) {
String[] parameters = new String[] {"path", "data"};
Object[] values = new Object[] {remotePath, base64Data};
return new AbstractMap.SimpleEntry>(PUSH_FILE, prepareArguments(parameters, values));
}
/**
* This method forms a {@link java.util.Map} of parameters for the
* setting of device network connection.
*
* @param connection The bitmask of the desired connection
* @return a key-value pair. The key is the command name. The value is a
* {@link java.util.Map} command arguments.
*/
public static Map.Entry> setConnectionCommand(Connection connection) {
String[] parameters = new String[] {"name", "parameters"};
Object[] values =
new Object[] {"network_connection", ImmutableMap.of("type", connection.bitMask)};
return new AbstractMap.SimpleEntry>(SET_NETWORK_CONNECTION, prepareArguments(parameters, values));
}
/**
* This method forms a {@link java.util.Map} of parameters for the
* activity starting.
*
* @param appPackage The package containing the activity. [Required]
* @param appActivity The activity to start. [Required]
* @param appWaitPackage Automation will begin after this package starts. [Optional]
* @param appWaitActivity Automation will begin after this activity starts. [Optional]
* @param intentAction Intent action which will be used to start activity [Optional]
* @param intentCategory Intent category which will be used to start activity [Optional]
* @param intentFlags Flags that will be used to start activity [Optional]
* @param optionalIntentArguments Additional intent arguments that will be used to
* start activity [Optional]
* @return a key-value pair. The key is the command name. The value is a
* {@link java.util.Map} command arguments.
* @throws IllegalArgumentException when any required argument is empty
*/
public static Map.Entry> startActivityCommand(String appPackage,
String appActivity, String appWaitPackage, String appWaitActivity,
String intentAction, String intentCategory, String intentFlags,
String optionalIntentArguments, boolean stopApp) throws IllegalArgumentException {
checkArgument((!StringUtils.isBlank(appPackage)
&& !StringUtils.isBlank(appActivity)),
String.format("'%s' and '%s' are required.", "appPackage", "appActivity"));
String targetWaitPackage = !StringUtils.isBlank(appWaitPackage) ? appWaitPackage : "";
String targetWaitActivity = !StringUtils.isBlank(appWaitActivity) ? appWaitActivity : "";
String targetIntentAction = !StringUtils.isBlank(intentAction) ? intentAction : "";
String targetIntentCategory = !StringUtils.isBlank(intentCategory) ? intentCategory : "";
String targetIntentFlags = !StringUtils.isBlank(intentFlags) ? intentFlags : "";
String targetOptionalIntentArguments = !StringUtils.isBlank(optionalIntentArguments)
? optionalIntentArguments : "";
ImmutableMap parameters = ImmutableMap
.builder().put("appPackage", appPackage)
.put("appActivity", appActivity)
.put("appWaitPackage", targetWaitPackage)
.put("appWaitActivity", targetWaitActivity)
.put("dontStopAppOnReset", !stopApp)
.put("intentAction", targetIntentAction)
.put("intentCategory", targetIntentCategory)
.put("intentFlags", targetIntentFlags)
.put("optionalIntentArguments", targetOptionalIntentArguments)
.build();
return new AbstractMap.SimpleEntry>(START_ACTIVITY, parameters);
}
/**
* This method forms a {@link java.util.Map} of parameters for the
* toggling of location services.
*
* @return a key-value pair. The key is the command name. The value is a
* {@link java.util.Map} command arguments.
*/
public static Map.Entry> toggleLocationServicesCommand() {
return new AbstractMap.SimpleEntry>(TOGGLE_LOCATION_SERVICES, ImmutableMap.of());
}
/**
* This method forms a {@link java.util.Map} of parameters for the
* device unlocking.
*
* @return a key-value pair. The key is the command name. The value is a
* {@link java.util.Map} command arguments.
*/
public static Map.Entry> unlockCommand() {
return new AbstractMap.SimpleEntry>(UNLOCK, ImmutableMap.of());
}
/**
* This method forms a {@link java.util.Map} of parameters for the
* device locking.
*
* @return a key-value pair. The key is the command name. The value is a
* {@link java.util.Map} command arguments.
*/
public static Map.Entry> lockDeviceCommand() {
return new AbstractMap.SimpleEntry>(LOCK, prepareArguments("seconds", 0));
}
/**
* This method forms a {@link java.util.Map} of parameters for the element
* value replacement. It is used against input elements
*
* @param hasIdentityObject an instance which contains an element ID
* @param value a new value
* @return a key-value pair. The key is the command name. The value is a
* {@link java.util.Map} command arguments.
*/
public static Map.Entry> replaceElementValueCommand(
HasIdentity hasIdentityObject, String value) {
String[] parameters = new String[] {"id", "value"};
Object[] values =
new Object[] {hasIdentityObject.getId(), value};
return new AbstractMap.SimpleEntry>(REPLACE_VALUE, prepareArguments(parameters, values));
}
}