def wait(condition: Callable,
max_timeout: int or float = 10,
sleep_time: int or float = 0.5,
waiting_for: str = '',
error_msg: str = '',
fail: bool = False,
xfail: bool = False,
logger: Logger = None):
"""
condition = callable or 'lambda: some_value'
"""
start_time = datetime.now()
while not condition():
time_delta = datetime.now() - start_time
message = f'Waiting for {waiting_for}... {time_delta.seconds}.{time_delta.microseconds} s'
if logger:
logger.log(message)
else:
print(message)
time.sleep(sleep_time)
if time_delta.seconds > max_timeout:
# if xfail:
# pytest.xfail(reason=error_msg)
# elif fail:
# pytest.fail(msg=error_msg)
# else:
raise TimeoutError(f'{error_msg} {time_delta}')
class EnvironmentAdapter:
environment_command = "environment_remote "
environment_remote = "com.github.remotesdk.ENVIRONMENT_REMOTE"
broadcast = "am broadcast -a "
es = " --es "
am_command = broadcast + environment_remote + es + environment_command
get_external_storage_directory_command = am_command + "getExternalStorageDirectory"
get_root_directory_command = am_command + "getRootDirectory"
get_data_directory_command = am_command + "getDataDirectory"
get_download_cache_directory_command = am_command + "getDownloadCacheDirectory"
get_storage_volumes_command = am_command + "getStorageVolumes"
def __init__(self, shell: AndroidShell):
self.shell = shell
self.logger = Logger(scope_name=shell.serial + "] [" +
EnvironmentAdapter.__name__)
def get_external_storage_directory(self) -> RemoteFile:
result = self.shell.execute_broadcast(
self.get_external_storage_directory_command)
self.logger.log(message="get external storage directory [" + result +
"]")
return RemoteFile(self.shell, result)
def get_root_directory(self) -> RemoteFile:
result = self.shell.execute_broadcast(self.get_root_directory_command)
self.logger.log(message="get root directory [" + result + "]")
return RemoteFile(self.shell, result)
def get_data_directory(self) -> RemoteFile:
result = self.shell.execute_broadcast(self.get_data_directory_command)
self.logger.log(message="get data directory [" + result + "]")
return RemoteFile(self.shell, result)
def get_download_cache_directory(self) -> RemoteFile:
result = self.shell.execute_broadcast(
self.get_download_cache_directory_command)
self.logger.log(message="get download cache directory [" + result +
"]")
return RemoteFile(self.shell, result)
def get_storage_volumes(self) -> list:
result = self.shell.execute_broadcast(self.get_storage_volumes_command)
name_spaces = json.loads(result,
object_hook=lambda d: StorageVolume(**d))
self.logger.log(message="get storage volumes")
return name_spaces
class BluetoothDevice:
bluetooth_command = "bluetooth_remote "
bluetooth_remote = "com.github.remotesdk.BLUETOOTH_REMOTE"
broadcast = "am broadcast -a "
es = " --es "
am_command = broadcast + bluetooth_remote + es + bluetooth_command
get_pair_state_command = am_command + "getPairState,"
get_device_name_command = am_command + "getDeviceName,"
get_device_type_command = am_command + "getDeviceType,"
get_device_class_command = am_command + "getDeviceClass,"
def __init__(self, shell: AndroidShell, address: str):
self.shell = shell
self.address = address
self.logger = Logger(scope_name=shell.serial + "] [" +
BluetoothDevice.__name__)
def get_pair_state(self) -> PairState:
result = PairState(
int(
self.shell.execute_broadcast(self.get_pair_state_command +
self.address)))
self.logger.log(message="get bluetooth device [" + self.address +
"] pair state [" + str(result.name) + "]")
return result
def get_name(self) -> str:
result = self.shell.execute_broadcast(self.get_device_name_command +
self.address)
self.logger.log(message="get bluetooth device [" + self.address +
"] name [" + str(result) + "]")
return result
def get_type(self) -> str:
result = Type(
int(
self.shell.execute_broadcast(self.get_device_type_command +
self.address)))
self.logger.log(message="get bluetooth device [" + self.address +
"] type [" + str(result.name) + "]")
return result
def get_bluetooth_class(self) -> BluetoothClass:
result = BluetoothClass(
int(
self.shell.execute_broadcast(self.get_device_class_command +
self.address)))
self.logger.log(message="get bluetooth device [" + self.address +
"] class [" + str(result) + "]")
return result
def __str__(self):
return self.address
class BluetoothAdapter:
bluetooth_address_pattern = "[\\s\\S]*address:[\\s\\S](.*)[\\s\\S]*"
bluetooth_command = "bluetooth_remote "
bluetooth_remote = "com.github.remotesdk.BLUETOOTH_REMOTE"
broadcast = "am broadcast -a "
es = " --es "
am_command = broadcast + bluetooth_remote + es + bluetooth_command
enable_command = am_command + "enable"
disable_command = am_command + "disable"
is_enabled_command = am_command + "isEnabled"
get_state_command = am_command + "getState"
get_address_command = "dumpsys bluetooth_manager"
discoverable_command = am_command + "discoverable,"
get_scan_mode_command = am_command + "getScanMode"
set_scan_mode_command = am_command + "setScanMode,"
get_name_command = am_command + "getName"
set_name_command = am_command + "setName,"
start_discovery_command = am_command + "startDiscovery"
cancel_discovery_command = am_command + "cancelDiscovery"
is_discovering_command = am_command + "isDiscovering"
pair_command = am_command + "pairDevice,"
get_discovered_devices_command = am_command + "getDiscoveredDevices"
get_paired_devices_command = am_command + "getBondedDevices"
get_bluetooth_device_command = am_command + "getRemoteDevice,"
factory_reset_command = am_command + "factoryReset"
remove_pair_command = am_command + "removeBond,"
get_pair_state_command = am_command + "getPairState,"
get_supported_profiles_command = am_command + "getSupportedProfiles"
get_profile_connected_state_command = am_command + "getProfileConnectionState,"
is_bluetooth_a2dp_on_command = am_command + "isBluetoothA2dpOn"
def __init__(self, shell: AndroidShell):
self.shell = shell
self.logger = Logger(scope_name=shell.serial + "] [" +
BluetoothAdapter.__name__)
def enable(self) -> None:
self.shell.execute_broadcast(self.enable_command)
self.logger.log(message="enable")
def disable(self) -> None:
self.shell.execute_broadcast(self.disable_command)
self.logger.log(message="disable")
def is_enabled(self) -> bool:
result = eval(
self.shell.execute_broadcast(self.is_enabled_command).title())
self.logger.log(message="is enabled [" + str(result) + "]")
return result
def get_state(self) -> State:
result = State(
int(self.shell.execute_broadcast(self.get_state_command)))
self.logger.log(message="get state [" + result.name + "]")
return result
def get_address(self) -> str:
result = self.shell.execute(self.get_address_command)
if re.match(self.bluetooth_address_pattern, result):
address = re.search(self.bluetooth_address_pattern,
result).group(1)
self.logger.log(message="get address [" + address + "]")
return address
else:
return ""
def get_scan_mode(self) -> ScanMode:
result = ScanMode(
int(self.shell.execute_broadcast(self.get_scan_mode_command)))
self.logger.log(message="get scan mode [" + result.name + "]")
return result
def set_scan_mode(self, scan_mode: ScanMode, time: int) -> bool:
result = eval(
self.shell.execute_broadcast(self.set_scan_mode_command +
str(scan_mode.value) + "," +
str(time)).title())
self.logger.log(message="set scan mode [" + str(scan_mode.name) +
"] [" + str(result) + "]")
return result
def start_discoverable(self, time: int) -> None:
self.shell.execute_broadcast(self.discoverable_command + str(time))
self.logger.log(message="start discoverable")
def cancel_discoverable(self) -> None:
self.set_scan_mode(ScanMode.SCAN_MODE_NONE, 0)
self.logger.log(message="cancel discoverable")
def is_discoverable(self) -> bool:
result = self.get_scan_mode(
) is ScanMode.SCAN_MODE_CONNECTABLE_DISCOVERABLE
self.logger.log(message="is discoverable [" + str(result) + "]")
return result
def get_name(self) -> str:
result = self.shell.execute_broadcast(self.get_name_command)
self.logger.log(message="get name [" + str(result) + "]")
return result
def set_name(self, name: str) -> bool:
result = eval(
self.shell.execute_broadcast(self.set_name_command + name).title())
self.logger.log(message="set name [" + str(name) + "] [" +
str(result) + "]")
return result
def start_discovery(self) -> bool:
result = eval(
self.shell.execute_broadcast(self.start_discovery_command).title())
self.logger.log(message="start discovery [" + str(result) + "]")
return result
def cancel_discovery(self) -> bool:
result = eval(
self.shell.execute_broadcast(
self.cancel_discovery_command).title())
self.logger.log(message="cancel discovery [" + str(result) + "]")
return result
def is_discovering(self) -> bool:
result = eval(
self.shell.execute_broadcast(self.is_discovering_command).title())
self.logger.log(message="is discovering [" + str(result) + "]")
return result
@Overload
@signature("str")
def pair(self, address: str) -> bool:
result = eval(
self.shell.execute_broadcast(self.pair_command +
str(address)).title())
self.logger.log(message="pair device [" + str(address) + "] [" +
str(result) + "]")
return result
@pair.overload
@signature("BluetoothDevice")
def pair(self, bluetooth_device: BluetoothDevice) -> bool:
return self.pair(bluetooth_device.address)
def get_discovered_devices(self) -> list:
devices = []
result = self.shell.execute_broadcast(
self.get_discovered_devices_command)
for address in result.split(","):
if address:
devices.append(BluetoothDevice(self.shell, address))
self.logger.log(message="get discovered devices")
return devices
def get_paired_devices(self) -> list:
devices = []
result = self.shell.execute_broadcast(self.get_paired_devices_command)
for address in result.split(","):
if address:
devices.append(BluetoothDevice(self.shell, address))
self.logger.log(message="get paired devices")
return devices
def get_bluetooth_device(self, address: str) -> BluetoothDevice:
result = BluetoothDevice(
self.shell,
self.shell.execute_broadcast(self.get_bluetooth_device_command +
address))
self.logger.log(message="get bluetooth device [" + str(address) + "]")
return result
def factory_reset(self) -> bool:
result = eval(
self.shell.execute_broadcast(self.factory_reset_command).title())
self.logger.log(message="factory reset [" + str(result) + "]")
return result
def remove_pair(self, address: str) -> bool:
result = eval(
self.shell.execute_broadcast(self.remove_pair_command +
address).title())
self.logger.log(message="remove pair [" + str(address) + "] [" +
str(result) + "]")
return result
def remove_all_paired_devices(self) -> None:
for device in self.get_paired_devices():
self.remove_pair(device.address)
def get_pair_state(self, address: str) -> PairState:
result = PairState(
int(
self.shell.execute_broadcast(self.get_pair_state_command +
address)))
self.logger.log(message="get device [" + address + "] pair state [" +
str(result.name) + "]")
return result
def get_supported_profiles(self) -> list:
profiles = []
result = self.shell.execute_broadcast(
self.get_supported_profiles_command)
for profile in result.split(","):
if profile:
profiles.append(ProfileType(int(profile)))
self.logger.log(message="get supported profiles")
return profiles
def get_profile_connected_state(self,
profile: ProfileType) -> ConnectedState:
result = ConnectedState(
int(
self.shell.execute_broadcast(
self.get_profile_connected_state_command +
str(profile.value))))
self.logger.log(message="get profile [" + str(profile.name) +
"] connected state [" + str(result.name) + "]")
def is_a2dp_on(self) -> bool:
result = eval(
self.shell.execute_broadcast(
self.is_bluetooth_a2dp_on_command).title())
self.logger.log(message="is A2DP on [" + str(result) + "]")
return result
class RemoteFile:
environment_command = "environment_remote "
environment_remote = "com.github.remotesdk.ENVIRONMENT_REMOTE"
broadcast = "am broadcast -a "
es = " --es "
am_command = broadcast + environment_remote + es + environment_command
is_file_exist_command = am_command + "isFileExist,"
list_files_command = am_command + "listFiles,"
is_directory_command = am_command + "isDirectory,"
is_file_command = am_command + "isFile,"
get_name_command = am_command + "getName,"
get_parent_command = am_command + "getParent,"
can_execute_command = am_command + "canExecute,"
can_read_command = am_command + "canRead,"
can_write_command = am_command + "canWrite,"
is_absolute_command = am_command + "isAbsolute,"
is_hidden_command = am_command + "isHidden,"
delete_command = am_command + "deleteFile,"
create_new_file_command = am_command + "createNewFile,"
make_dir_command = am_command + "makeDir,"
make_dirs_command = am_command + "createDirs,"
rename_to_command = am_command + "renameTo,"
set_readable_command = am_command + "setReadable,"
set_writable_command = am_command + "setWritable,"
set_executable_command = am_command + "setExecutable,"
get_total_space_command = am_command + "getTotalSpace,"
last_modified_command = am_command + "lastModified,"
def __init__(self, shell: AndroidShell, path: str):
self.shell = shell
self.path = path
self.logger = Logger(scope_name=shell.serial + "] [" +
RemoteFile.__name__)
def exist(self) -> bool:
result = eval(
self.shell.execute_broadcast(self.is_file_exist_command +
self.path).title())
self.logger.log(message="is [" + self.path + "] exist [" +
str(result) + "]")
return result
def list_files(self) -> list:
result = self.shell.execute_broadcast(self.list_files_command +
self.path)
listFiles = []
try:
for item in result.replace("[", "").replace("]", "").split(","):
listFiles.append(RemoteFile(self.shell, item.strip()))
except:
pass
self.logger.log(message="list files [" + self.path + "]")
return listFiles
def is_directory(self) -> bool:
result = eval(
self.shell.execute_broadcast(self.is_directory_command +
self.path).title())
self.logger.log(message="is [" + self.path + "] directory [" +
str(result) + "]")
return result
def is_file(self) -> bool:
result = eval(
self.shell.execute_broadcast(self.is_file_command +
self.path).title())
self.logger.log(message="is [" + self.path + "] file [" + str(result) +
"]")
return result
def get_name(self) -> str:
result = self.shell.execute_broadcast(self.get_name_command +
self.path)
self.logger.log(message="get [" + self.path + "] name [" +
str(result) + "]")
return result
def get_parent(self):
result = self.shell.execute_broadcast(self.get_parent_command +
self.path)
self.logger.log(message="get [" + self.path + "] parent [" +
str(result) + "]")
return RemoteFile(self.shell, result)
def can_execute(self) -> bool:
result = eval(
self.shell.execute_broadcast(self.can_execute_command +
self.path).title())
self.logger.log(message="can execute [" + self.path + "] [" +
str(result) + "]")
return result
def can_read(self) -> bool:
result = eval(
self.shell.execute_broadcast(self.can_read_command +
self.path).title())
self.logger.log(message="can read [" + self.path + "] [" +
str(result) + "]")
return result
def can_write(self) -> bool:
result = eval(
self.shell.execute_broadcast(self.can_write_command +
self.path).title())
self.logger.log(message="can write [" + self.path + "] [" +
str(result) + "]")
return result
def is_absolute(self) -> bool:
result = eval(
self.shell.execute_broadcast(self.is_absolute_command +
self.path).title())
self.logger.log(message="is absolute [" + self.path + "] [" +
str(result) + "]")
return result
def is_hidden(self) -> bool:
result = eval(
self.shell.execute_broadcast(self.is_hidden_command +
self.path).title())
self.logger.log(message="is hidden [" + self.path + "] [" +
str(result) + "]")
return result
def delete(self) -> bool:
result = eval(
self.shell.execute_broadcast(self.delete_command +
self.path).title())
self.logger.log(message="delete [" + self.path + "] [" + str(result) +
"]")
return result
def create_new_file(self) -> bool:
result = eval(
self.shell.execute_broadcast(self.create_new_file_command +
self.path).title())
self.logger.log(message="create new file [" + self.path + "] [" +
str(result) + "]")
return result
def make_dir(self) -> bool:
result = eval(
self.shell.execute_broadcast(self.make_dir_command +
self.path).title())
self.logger.log(message="make dir [" + self.path + "] [" +
str(result) + "]")
return result
def make_dirs(self) -> bool:
result = eval(
self.shell.execute_broadcast(self.make_dirs_command +
self.path).title())
self.logger.log(message="make dirs [" + self.path + "] [" +
str(result) + "]")
return result
def rename_to(self, rename: str) -> bool:
result = eval(
self.shell.execute_broadcast(self.rename_to_command + self.path +
"," + rename).title())
if rename:
self.path = rename
self.logger.log(message="rename [" + self.path + "] to [" + rename +
"] [" + str(result) + "]")
return result
def get_total_space(self) -> int:
result = int(
self.shell.execute_broadcast(self.get_total_space_command +
self.path))
self.logger.log(message="get total space [" + self.path + "] [" +
str(result) + "]")
return result
def last_modified(self) -> int:
result = int(
self.shell.execute_broadcast(self.last_modified_command +
self.path))
self.logger.log(message="last modified [" + self.path + "] [" +
str(result) + "]")
return result
def __str__(self):
return self.path
class RemoteController:
def __init__(self, serial):
self.serial = serial
self.shell = AndroidShell(serial)
self.logger = Logger(scope_name=RemoteController.__name__)
def get_bluetooth_adapter(self) -> BluetoothAdapter:
self.logger.log(message="get bluetooth adapter")
return BluetoothAdapter(self.shell)
def get_wifi_adapter(self) -> WifiAdapter:
self.logger.log(message="get wifi adapter")
return WifiAdapter(self.shell)
def get_telecom_adapter(self) -> TelecomAdapter:
self.logger.log(message="get telecom adapter")
return TelecomAdapter(self.shell)
def get_environment_adapter(self) -> EnvironmentAdapter:
self.logger.log(message="get environment adapter")
return EnvironmentAdapter(self.shell)
def get_remote_file(self, path: str) -> RemoteFile:
self.logger.log(message="get remote file")
return RemoteFile(self.shell, path)
def get_usb_adapter(self) -> UsbAdapter:
self.logger.log(message="get usb adapter")
return UsbAdapter(self.shell)
def get_player_adapter(self) -> PlayerAdapter:
self.logger.log(message="get player adapter")
return PlayerAdapter(self.shell)
def start_view(self, actions: Actions):
self.shell.execute(
"am start -a " + actions.value +
" -f 0x20000000 --activity-single-top --activity-clear-when-task-reset"
)
self.logger.log(message="start action [" + actions.value + "]")
class UsbAdapter:
usb_command = "usb_remote "
usb_remote = "com.github.remotesdk.USB_REMOTE"
broadcast = "am broadcast -a "
es = " --es "
am_command = broadcast + usb_remote + es + usb_command
get_device_list_command = am_command + "getDeviceList"
get_input_device_list_command = am_command + "getInputDeviceList"
def __init__(self, shell: AndroidShell):
self.shell = shell
self.logger = Logger(scope_name=shell.serial + "] [" +
UsbAdapter.__name__)
def get_input_device_list(self) -> list:
list_devices = []
result = self.shell.execute_broadcast(
self.get_input_device_list_command)
name_spaces = json.loads(result,
object_hook=lambda d: SimpleNamespace(**d))
for item in name_spaces:
list_devices.append(
InputDevice(generation=item.generation,
virtual=item.virtual,
productId=item.productId,
sources=item.sources,
vendorId=item.vendorId,
descriptor=item.descriptor,
enabled=item.enabled,
external=item.external,
keyboardType=item.keyboardType,
controllerNumber=item.controllerNumber,
name=item.name,
id=item.id,
fullKeyboard=item.fullKeyboard))
self.logger.log(message="get input device list")
return list_devices
def get_usb_device_list(self) -> list:
list_devices = []
result = self.shell.execute_broadcast(self.get_device_list_command)
name_spaces = json.loads(result,
object_hook=lambda d: SimpleNamespace(**d))
for item in name_spaces:
list_devices.append(
UsbDevice(deviceProtocol=item.deviceProtocol,
hasVideoPlayback=item.hasVideoPlayback,
serialNumber=item.serialNumber,
productId=item.productId,
manufacturerName=item.manufacturerName,
vendorId=item.vendorId,
deviceSubclass=item.deviceSubclass,
deviceId=item.deviceId,
deviceName=item.deviceName,
version=item.version,
hasAudioPlayback=item.hasAudioPlayback,
productName=item.productName,
configurationCount=item.configurationCount,
deviceClass=item.deviceClass,
interfaceCount=item.interfaceCount,
hasVideoCapture=item.hasVideoCapture,
hasMidi=item.hasMidi,
hasAudioCapture=item.hasAudioCapture))
self.logger.log(message="get usb device list")
return list_devices
class PlayerAdapter:
player_command = "player_command "
player_remote = "com.github.remotesdk.PLAYER_REMOTE"
broadcast = "am broadcast -a "
es = " --es "
am_command = broadcast + player_remote + es + player_command
play_song_command = am_command + "playSong,"
stop_song_command = am_command + "stopSong"
seek_to_command = am_command + "seekToSong,"
get_duration_command = am_command + "getSongDuration"
get_current_position_command = am_command + "getSongCurrentPosition"
is_song_playing_command = am_command + "isSongPlaying"
is_song_looping_command = am_command + "isSongLooping"
set_looping_command_command = am_command + "setSongLooping"
display_video_command = am_command + "displayVideo,"
def __init__(self, shell: AndroidShell):
self.shell = shell
self.logger = Logger(scope_name=shell.serial + "] [" +
PlayerAdapter.__name__)
@Overload
@signature("str")
def play(self, file: str) -> None:
self.shell.execute_broadcast(self.play_song_command + file)
self.logger.log(message="play [" + file + "]")
@play.overload
@signature("RemoteFile")
def play(self, file: RemoteFile):
self.play(file.path)
def stop(self) -> None:
self.shell.execute_broadcast(self.stop_song_command)
self.logger.log(message="stop play")
def seek_to(self, seek_time: int) -> None:
self.shell.execute_broadcast(self.seek_to_command + str(seek_time))
self.logger.log(message="seek to [" + str(seek_time) + "]")
def get_duration(self) -> int:
result = int(self.shell.execute_broadcast(self.get_duration_command))
self.logger.log(message="get duration [" + str(result) + "]")
return result
def get_current_position(self) -> int:
result = int(
self.shell.execute_broadcast(self.get_current_position_command))
self.logger.log(message="get current position [" + str(result) + "]")
return result
def is_playing(self) -> bool:
result = eval(
self.shell.execute_broadcast(self.is_song_playing_command).title())
self.logger.log(message="is playing [" + str(result) + "]")
return result
class TelecomAdapter:
telecom_command = "telephony_remote "
telecom_remote = "com.github.remotesdk.TELEPHONY_REMOTE"
broadcast = "am broadcast -a "
es = " --es "
am_command = broadcast + telecom_remote + es + telecom_command
get_call_state_command = am_command + "getCallState"
get_call_history_command = am_command + "getCallHistory"
get_contacts_command = am_command + "getContacts"
call_command = "am start -a android.intent.action.CALL -d tel:"
end_call_command = am_command + "endCallProgrammatically"
answer_ringing_call_command = am_command + "answerRingingCall"
get_incoming_call_number_command = am_command + "getIncomingCallNumber"
set_data_enabled_command = am_command + "setDataEnabled,"
is_data_enabled_command = am_command + "isDataEnabled"
get_data_state_command = am_command + "getDataState"
get_data_network_type_command = am_command + "getDataNetworkType"
get_phone_type_command = am_command + "getPhoneType"
get_sim_state_command = am_command + "getSimState"
get_network_operator_name_command = am_command + "getNetworkOperatorName"
send_ussd_request_command = am_command + "sendUssdRequest,"
get_ussd_responce_command = am_command + "getUssdResponse"
get_mobile_phone_command = am_command + "getMobilePhone"
def __init__(self, shell: AndroidShell):
self.shell = shell
self.logger = Logger(scope_name=shell.serial + "] [" +
TelecomAdapter.__name__)
def get_call_state(self) -> CallState:
result = CallState(
int(self.shell.execute_broadcast(self.get_call_state_command)))
self.logger.log(message="get call state [" + result.name + "]")
return result
def get_call_history(self) -> list:
result = self.shell.execute_broadcast(self.get_call_history_command)
call_history_list = json.loads(result,
object_hook=lambda d: CallHistory(**d))
self.logger.log(message="get call history")
return call_history_list
def get_contacts(self) -> list:
result = self.shell.execute_broadcast(self.get_contacts_command)
contacts_list = json.loads(result, object_hook=lambda d: Contacts(**d))
self.logger.log(message="get contacts")
return contacts_list
def call(self, number: str) -> None:
self.shell.execute(self.call_command + number)
self.logger.log(message="call number [" + number + "]")
def end_call(self) -> None:
self.shell.execute_broadcast(self.end_call_command)
self.logger.log(message="end call")
def answer_incoming_call(self) -> None:
self.shell.execute_broadcast(self.answer_ringing_call_command)
self.logger.log(message="answer incoming call")
def get_incoming_call_number(self) -> str:
result = self.shell.execute_broadcast(self.answer_ringing_call_command)
self.logger.log(message="get incoming call number [" + result + "]")
return result
def set_data_enabled(self, state: bool) -> None:
self.shell.execute_broadcast(self.set_data_enabled_command +
str(state))
self.logger.log(message="set data enabled [" + str(state) + "]")
def is_data_enabled(self) -> bool:
result = eval(
self.shell.execute_broadcast(self.is_data_enabled_command).title())
self.logger.log(message="is data enabled [" + str(result) + "]")
def get_data_state(self) -> DataState:
result = DataState(
int(self.shell.execute_broadcast(self.get_data_state_command)))
self.logger.log(message="get data state [" + result.name + "]")
return result
def get_data_network_type(self) -> DataNetworkType:
result = DataNetworkType(
int(
self.shell.execute_broadcast(
self.get_data_network_type_command)))
self.logger.log(message="get data network type [" + result.name + "]")
return result
def get_phone_type(self) -> PhoneType:
result = PhoneType(
int(self.shell.execute_broadcast(self.get_phone_type_command)))
self.logger.log(message="get phone type [" + result.name + "]")
return result
def get_sim_state(self) -> SimState:
result = SimState(
int(self.shell.execute_broadcast(self.get_sim_state_command)))
self.logger.log(message="get sim state [" + result.name + "]")
return result
def get_network_operator_name(self) -> str:
result = self.shell.execute_broadcast(
self.get_network_operator_name_command)
self.logger.log(message="get network operator name [" + result + "]")
return result
def send_ussd_request(self, ussd: str) -> str:
self.shell.execute_broadcast(self.send_ussd_request_command + ussd)
time.sleep(2)
result = self.shell.execute_broadcast(self.get_ussd_responce_command)
self.logger.log(message="send ussd request [" + ussd + "] [" + result +
"]")
return result
def get_mobile_phone(self) -> str:
result = self.shell.execute_broadcast(self.get_mobile_phone_command)
self.logger.log(message="get mobile phone [" + result + "]")
return result
class WifiAdapter:
wifi_command = "wifi_remote "
wifi_remote = "com.github.remotesdk.WIFI_REMOTE"
broadcast = "am broadcast -a "
es = " --es "
am_command = broadcast + wifi_remote + es + wifi_command
enable_command = am_command + "enable"
disable_command = am_command + "disable"
get_state_command = am_command + "getState"
is_enabled_command = am_command + "isEnabled"
get_wifi_hotspot_config_command = am_command + "getWifiApConfiguration"
add_network_command = am_command + "addNetwork,"
enable_network_command = am_command + "enableNetwork,"
disable_network_command = am_command + "disableNetwork,"
remove_network_command = am_command + "removeNetwork,"
get_configured_networks_command = am_command + "getConfiguredNetworks"
disconnect_command = am_command + "disconnect"
set_hotspot_config_command = am_command + "setWifiApConfiguration,"
is_hotspot_enabled_command = am_command + "isWifiApEnabled"
start_tethering_command = am_command + "startTethering"
stop_tethering_command = am_command + "stopTethering"
get_hotspot_state_command = am_command + "getWifiApState"
reconnect_command = am_command + "reconnect"
reassociate_command = am_command + "reassociate"
start_scan_command = am_command + "startScan"
get_scan_results_command = am_command + "getScanResults"
is_connected_network_command = am_command + "isWifiNetworkConnected"
set_scan_always_available_command = am_command + "setScanAlwaysAvailable,"
get_scan_always_available_command = am_command + "getScanAlwaysAvailable"
def __init__(self, shell: AndroidShell):
self.shell = shell
self.logger = Logger(scope_name=shell.serial + "] [" +
WifiAdapter.__name__)
def enable(self) -> bool:
result = eval(
self.shell.execute_broadcast(self.enable_command).title())
self.logger.log(message="enable [" + str(result) + "]")
return result
def disable(self) -> bool:
result = eval(
self.shell.execute_broadcast(self.disable_command).title())
self.logger.log(message="disable [" + str(result) + "]")
return result
def get_state(self) -> State:
result = State(
int(self.shell.execute_broadcast(self.get_state_command)))
self.logger.log(message="get satate [" + str(result.name) + "]")
return result
def is_enabled(self) -> bool:
result = eval(
self.shell.execute_broadcast(self.is_enabled_command).title())
self.logger.log(message="is enabled [" + str(result) + "]")
return result
def get_hotspot_configuration(self) -> WifiConfiguration:
result = self.shell.execute_broadcast(
self.get_wifi_hotspot_config_command)
name_spaces = json.loads(result,
object_hook=lambda d: SimpleNamespace(**d))
config = WifiConfiguration(SSID=name_spaces.SSID,
preSharedKey=name_spaces.preSharedKey,
networkId=name_spaces.networkId,
security_type=SecurityType.PASS)
self.logger.log(message="get hotspot configuration")
return config
@Overload
@signature("str", "str", "SecurityType")
def add_network(self, ssid: str, password: str,
security_type: SecurityType) -> int:
result = int(
self.shell.execute_broadcast(self.add_network_command + ssid +
"," + password + "," +
str(security_type.value)))
self.logger.log(message="add network ssid [" + ssid + "] pass [" +
password + "] config [" + str(security_type.name) +
"] [" + str(result) + "]")
return result
@add_network.overload
@signature("WifiConfiguration")
def add_network(self, wifi_configuration: WifiConfiguration) -> int:
return self.add_network(wifi_configuration.SSID,
wifi_configuration.preSharedKey,
wifi_configuration.security_type)
def enable_network(self, net_id: int) -> bool:
result = eval(
self.shell.execute_broadcast(self.enable_network_command +
str(net_id)).title())
self.logger.log(message="enable network id [" + str(net_id) + "] [" +
str(result) + "]")
return result
def disable_network(self, net_id: int) -> bool:
result = eval(
self.shell.execute_broadcast(self.disable_network_command +
str(net_id)).title())
self.logger.log(message="enable network id [" + str(net_id) + "] [" +
str(result) + "]")
return result
def remove_network(self, net_id: int) -> bool:
result = eval(
self.shell.execute_broadcast(self.remove_network_command +
str(net_id)).title())
self.logger.log(message="remove network id [" + str(net_id) + "] [" +
str(result) + "]")
return result
def remove_all_networks(self) -> None:
for config in self.get_configured_networks():
self.remove_network(config.networkId)
def get_configured_networks(self) -> list:
networks = []
result = self.shell.execute_broadcast(
self.get_configured_networks_command)
name_spaces = json.loads(result,
object_hook=lambda d: SimpleNamespace(**d))
for item in name_spaces:
networks.append(
WifiConfiguration(SSID=item.SSID,
preSharedKey=item.preSharedKey,
networkId=int(item.networkId),
security_type=SecurityType.PASS))
self.logger.log(message="get configured networks")
return networks
def disconnect(self) -> bool:
result = eval(
self.shell.execute_broadcast(self.disconnect_command).title())
self.logger.log(message="disconnect [" + str(result) + "]")
return result
@Overload
@signature("str", "str", "SecurityType")
def set_hotspot_configuration(self, ssid: str, password: str,
security_type: SecurityType) -> bool:
result = eval(
self.shell.execute_broadcast(self.set_hotspot_config_command +
ssid + "," + password + "," +
str(security_type.value)).title())
self.logger.log(message="set hotspot configuration [" + ssid +
"] pass [" + password + "] config [" +
str(security_type.name) + "] [" + str(result) + "]")
return result
@set_hotspot_configuration.overload
@signature("WifiConfiguration")
def set_hotspot_configuration(
self, wifi_configuration: WifiConfiguration) -> bool:
return self.set_hotspot_configuration(
ssid=wifi_configuration.SSID,
password=wifi_configuration.preSharedKey,
security_type=wifi_configuration.security_type)
def is_hotspot_enabled(self) -> bool:
result = eval(
self.shell.execute_broadcast(
self.is_hotspot_enabled_command).title())
self.logger.log(message="is hotspot enabled [" + str(result) + "]")
return result
def start_tethering(self) -> bool:
result = eval(
self.shell.execute_broadcast(self.start_tethering_command).title())
self.logger.log(message="start hotspot tethering [" + str(result) +
"]")
return result
def stop_tethering(self):
self.shell.execute_broadcast(self.stop_tethering_command)
self.logger.log(message="stop hotspot tethering")
def get_hotspot_state(self) -> State:
result = State(
int(self.shell.execute_broadcast(self.get_hotspot_state_command)))
self.logger.log(message="get hotspot state [" + str(result.name) + "]")
return result
def reconnect(self) -> bool:
result = eval(
self.shell.execute_broadcast(self.reconnect_command).title())
self.logger.log(message="reconnect [" + str(result) + "]")
return result
def reassociate(self) -> bool:
result = eval(
self.shell.execute_broadcast(self.reassociate_command).title())
self.logger.log(message="reassociate [" + str(result) + "]")
return result
def start_scan(self) -> bool:
result = eval(
self.shell.execute_broadcast(self.start_scan_command).title())
self.logger.log(message="start scan [" + str(result) + "]")
return result
def get_scan_results(self) -> list:
scan_results = []
result = self.shell.execute_broadcast(self.get_scan_results_command)
name_spaces = json.loads(result,
object_hook=lambda d: SimpleNamespace(**d))
for item in name_spaces:
scan_results.append(
ScanResult(SSID=item.SSID,
BSSID=item.BSSID,
hessid=item.hessid,
anqpDomainId=item.anqpDomainId,
capabilities=item.capabilities,
level=item.level,
frequency=item.frequency,
channelWidth=item.channelWidth,
timestamp=item.timestamp,
seen=item.seen,
untrusted=item.untrusted,
numUsage=item.numUsage,
distanceCm=item.distanceCm,
distanceSdCm=item.distanceSdCm))
self.logger.log(message="get scan results")
return scan_results
def is_network_connected(self) -> bool:
result = eval(
self.shell.execute_broadcast(
self.is_connected_network_command).title())
self.logger.log(message="is network connected [" + str(result) + "]")
return result
def set_scan_always_available(self, state: bool) -> bool:
result = eval(
self.shell.execute_broadcast(
self.set_scan_always_available_command + state).title())
self.logger.log(message="set scan always available [" + str(result) +
"]")
return result
def get_scan_always_available(self) -> bool:
result = eval(
self.shell.execute_broadcast(
self.get_scan_always_available_command).title())
self.logger.log(message="get scan always available [" + str(result) +
"]")
return result