Buongiorno,

sono un nuovo utente del forum alla ricerca di qualche consiglio... Avrei bisogno di qualche chiarimento su come utilizzare il metodo "subprocess.Popen" per gestire l'eseguibile "adb.exe" durante le operazioni di I/O su smartphone Android. Di seguito condivido lo script realizzato e l'output ottenuto.

Code:

import subprocess


# Avvio del processo
command = ""
process = ""
adb_path = "D:/ADBandFastboot/adb.exe"
process = subprocess.Popen([adb_path, command], shell=True, text=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE) # line buffering

try:

command = 'D:/ADBandFastboot/adb.exe devices'
stdout_value=process.stdin.write(command)
print(process.args)
print(process.stdin.write)
print(stdout_value)
stdout, stderr = process.communicate(timeout=20)
print("Output:", stdout)
print("Errori:\n", stderr)

except subprocess.TimeoutExpired:
print("Il processo ha impiegato troppo tempo e verrà terminato.")
process.kill()

except Exception as e:
print("Si è verificato un errore:", e)

finally:
process.stdin.close() # chiude i flussi stdin

Output dopo l'esecuzione:

['D:/ADBandFastboot/adb.exe', '']
<built-in method write of _io.TextIOWrapper object at 0x0000012053511D20>
38
Output:
Errori:
Android Debug Bridge version 1.0.35
Revision fc2a139a55f5-android

-a - directs adb to listen on all interfaces for a connection

--- Ultima modifica di FaMel 79 in data 2024-12-18 17:31:12 ---

--- Ultima modifica di FaMel 79 in data 2024-12-18 17:40:09 ---

Scusa se intervengo solo per porre una domanda, non ho alcuna pratica di interfacciamento con sistemi android ma il quesito mi ha incuriosito.

Domanda : le operazioni di I/O che stai cercando di effettuare sono da un sistema operativo "altro" (tipo windows, linux, etc.) verso un dispositivo android collegato, ovvero direttamente in una applicazione funzionante in un dispositivo android?




Chiarendo tale "ambiguità" scaturiscono linee di ricerca diverse, con risultati, nel primo caso, anche direttamente collegati al quesito, tipo questo, od anche inerenti tools specifici, tipo questo, mentre nel secondo, a giudicare da questo, sembra una problematica tutt'altro che semplice.




Come detto, la Tua domanda mi ha incuriosito, "abd.exe" mi è sconosciuto (uso solo sistemi linux) ma se precisi cosa intendi fare e come si potrebbe cercare qualcosa di specifico al Tuo problema.




Ciao

Ciao nuzzopippo,

si le operazioni di I/O sono da sistema Windows verso un dispositivo android collegato via usb al pc e viceversa. Il tool "adb.exe" è un sw free reperibili sul web; a me serve per trasferire file, immagini, ecc... dal pc windows verso lo smartphone android.

Il mio scopo è:

1) runnare l'eseguibile "adb.exe" ed avere il "PID" specifico del processo "adb.exe" in running;
2) dare un comando tipo "adb devices" utilizzando lo stesso PID del punto 1;
3) catturare l'output di ritorno del punto 2;
4) eventualmente dare altri comandi tipo adb push/adb pull sempre utilizzando il PID del punto 1;
5) catturare l'output di ritorno del punto 4;
6) uscire dallo script con un comando specifico tipo "exit" per terminare lo script.

Le operazioni di apertura dell'eseguibile ho pensato di farle con il comando:

process = subprocess.Popen([adb_path, command], shell=True, text=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE) # line buffering

L'iterazione con i comandi successivi (adb push/adb pull) la farei con un ciclo while e if con un break di uscita.

L'invio dei comandi "adb push/adb pull" verso il processo "adb.exe" lo sto eseguendo con il comando:

stdout_value=process.stdin.write(command)

Credo che il problema sia nel punto riportato sopra "process.stdin.write(command)"; ogni stringa che viene passata con la variabile "command", viene restituito un valore numerico sulla variabile "stdout_value".

Ho pensato questo modo per interagire con l'eseguibile "adb.exe" ma altri metodi per gestire il flusso operativo riportato sopra (punti 1 - 6) sono ben accetti.

Grazie per il supporto.

F

Come detto, il mondo Android mi è sconosciuto, cercando in merito ad "adb" ho scoperto che esiste anche per il mondo linux, scusa se inserisco un tip per eventuali linux-users interessati :

può essere installato dal Vostro gestore di pacchetti, in distro debian-based:

NzP:~$ sudo apt install adb

Si tratta dello Android-SDK di google.

Il comando "adb" che avrete disponibile è, essenzialmente, un server, capace di rilevare dispositivi in rete, udb/seriale, etc. il solito "man adb" per le numerose opzioni disponibili.




Se il dispositivo "collegato" non avrà abilitata tra le opzioni dello sviluppatore la modalità "debug USB" esso NON sarà disponibile anche se collegato.




Venendo a python, cercando di muovere i primi passi utilizzando la metodica proposta dallo O.P., utilizzando un vecchio "LG Bello II" molto vecchio, mi è riuscito di vedere il device in questo modo :

import subproces
result = subprocess.check_output(['adb', 'devices'])
                          
result
b'List of devices attached\n0123456789ABCDEF\tunauthorized\n\n'
data = result.decode('utf-8')
data
'List of devices attached\n0123456789ABCDEF\tunauthorized\n\n'
device = data.split('\n')1.split('\t')
print(f'device {device0} - stato {device1}')
device 0123456789ABCDEF - stato unauthorized

mi è riuscito di avere gli stessi risultati tramite Popen, ma senza utilizzo della shell

adb_sh = subprocess.Popen(['adb', 'devices'],
                          stdin=subprocess.PIPE,
                          stdout=subprocess.PIPE,
                          stderr=subprocess.PIPE)
out, err = adb_sh.communicate()
out
b'List of devices attached\n0123456789ABCDEF\tunauthorized\n\n'

dato che l'utilizzo della shell scatena una miriade di output, attivando, se ho capito bene, il server

adb_sh = subprocess.Popen(['adb', 'devices'],
                          shell=True,
                          stdin=subprocess.PIPE,
                          stdout=subprocess.PIPE,
                          stderr=subprocess.PIPE)
out, err = adb_sh.communicate()
out
b'Android Debug Bridge version 1.0.41\nVersion 34.0.4-debian\nInstalled as
 /usr/lib/android-sdk/platform-tools/adb\nRunning on Linux 6.8.0-50-generic...

rendendo ingestibile l'output.

Non ho ancora ben capito come funziona la shell con adb, l'impressione è che venga chiusa appena eseguito un comando, al momento non ho motivo di pensare che rimanga disponibile un PID, mi riservo di approfondire.




@FaMel 79, Tu sei riuscito a vedere i Tuoi devices? Se la risposta è "NO" prova a sostituire al mio "adb" il pathmane del Tuo eseguibile, oltre, naturalmente, a verificare le impostazioni del Tuo device.

per inviare i comandi si dovrebbe utilizzare "communicate" inviando i comandi come byte (stringa.encode()) e sopra vi è esempio di come recuperare lo standard output e lo standard error.




Al momento è quello che posso, spero Ti sia utile, ciao

Aggiornamento:




A giudicare da quanto letto, partendo da questa pagina, mi son convinto che "adb" esegua un comando alla volta e poi ritorni immediatamente, no vi dovrebbe essere una shell disponibile, quindi la modalità "interattiva" richiesta dallo OP non vale la pena di essere perseguita (ci risparmiamo un po' di thread per lettura/scrittura e relativa queue).

Il mio dispositivo di test dispone di Android 5.0, quindi va a farsi benedire l'accesso in rete riportato nel link, può essere utilizzato solo su usb, approfittando del fatto che deve essere l'unico dispositivo connesso con tale modalità (adb darebbe errore altrimenti), ho verificato che è possibile tranquillamente navigare il file-system del cellulare e copiarsi dei files li depositati, vedere sessione sotto (ridotta per quanto possibile)

Python 3.12.3 (main, Nov  6 2024, 18:32:19) [GCC 13.2.0] on linux
Type "help", "copyright", "credits" or "license()" for more information.
import subprocess as sp
result = sp.check_output(['adb', 'devices', '-l'])
result
b'List of devices attached\n0123456789ABCDEF       device usb:3-8 product:V10_open_eu model:LG X150 device:v10 transport_id:1\n\n'
result = sp.check_output(['adb', 'shell', 'ls', '-l', '/'])
text = result.decode()
data = text.split('\r\n')
for r in data:
    print(r)

    
drwxr-xr-x root     root              2010-01-01 01:47 acct
drwxrwx--- system   cache             2010-01-01 01:07 cache
lrwxrwxrwx root     root              1970-01-01 01:00 charger -> /sbin/healthd
dr-x------ root     root              2010-01-01 01:47 config
...
-rw-r--r-- root     root        30298 1970-01-01 01:00 file_contexts
lstat '//flex' failed: Permission denied
-rw-r----- root     root         1712 1970-01-01 01:00 fstab.mt6582
...
-rw-r--r-- root     root        11264 1970-01-01 01:00 service_contexts
drwxr-x--x root     sdcard_r          2010-01-01 01:47 storage
dr-xr-xr-x root     root              2010-01-01 01:47 sys
drwxr-xr-x root     root              1970-01-01 01:00 system
...
result = sp.check_output(['adb', 'shell', 'ls', '-l', '/storage'])
text = result.decode()
data = text.split('\r\n')
for r in data:
    print(r)

    
drwxr-xr-x media_rw media_rw          2010-01-01 01:47 emulated
lrwxrwxrwx root     root              2010-01-01 01:47 sdcard0 -> /storage/emulated/legacy
drwxrwx--x root     sdcard_r          1970-01-01 01:00 sdcard1
drwx------ root     root              2010-01-01 01:47 usbotg

result = sp.check_output(['adb', 'shell', 'ls', '-l', '/storage/sdcard1'])
text = result.decode()
data = text.split('\r\n')
for r in data:
    print(r)

    
drwxrwx--x root     sdcard_r          2014-02-03 08:40 Android
drwxrwx--- root     sdcard_r          2014-02-03 08:38 DCIM
drwxrwx--- root     sdcard_r          2014-02-03 08:32 LOST.DIR
drwxrwx--- root     sdcard_r          2016-06-25 12:03 Recording
drwxrwx--- root     sdcard_r          2015-10-25 15:05 bluetooth
drwxrwx--- root     sdcard_r          2020-10-06 17:54 documents
drwxrwx--- root     sdcard_r          2021-05-30 06:32 download
drwxrwx--- root     sdcard_r          2014-02-03 08:32 foursquare
drwxrwx--- root     sdcard_r          2014-06-03 07:49 musica
drwxrwx--- root     sdcard_r          2018-07-30 12:12 video

result = sp.check_output(['adb', 'shell', 'ls', '-l', '/storage/sdcard1/documents'])
text = result.decode()
data = text.split('\r\n')
for r in data:
    print(r)

    
-rwxrwx--- root     sdcard_r  2029923 2016-06-25 22:31 BREAKING DAWN.pdf
-rwxrwx--- root     sdcard_r  1586880 2016-06-25 19:32 ECLIPSE.pdf
-rwxrwx--- root     sdcard_r  1384907 2016-06-25 20:32 NEW MOON.pdf
drwxrwx--- root     sdcard_r          2015-08-15 19:10 Sample Files
-rwxrwx--- root     sdcard_r   624276 2016-06-25 20:33 Stephenie Meyer - MIDNIGHT SUN (cap 1-12)_italiano.pdf
-rwxrwx--- root     sdcard_r  1282329 2016-06-25 20:33 Twilight.pdf


result = sp.check_output(['adb', 'pull', '/storage/sdcard1/documents/ECLIPSE.pdf', '/home/ngiuseppe'])
result
b'/storage/sdcard1/documents/ECLIPSE.pdf: 1 file pulled, 0 skipped. 4.4 MB/s (1586880 bytes in 0.345s)\n'

ho voluto mostrare come son proceduto nella navigazione ed il risultato della copia da cellulare a computer, modalità analoghe dovrebbero funzionare per fare l'inverso.




Spero possa essere utile.

Ciao