Recupera il database o qualsiasi altro file dalla memoria interna utilizzando run-as

Su un dispositivo Android non rootato, posso navigare nella cartella dei dati contenente il database utilizzando il run-ascomando con il nome del mio pacchetto. La maggior parte dei tipi di file mi accontento di visualizzare, ma con il database vorrei estrarre se dal dispositivo Android.

Esiste un comando download copyo moveda questa parte della shell adb? Vorrei scaricare il file di database e visualizzarne il contenuto utilizzando un browser di database.

Una risposta qui implica trasformare l'intero pacchetto dell'applicazione in un archivio compresso, ma non ci sono ulteriori risposte su come estrarre quell'archivio una volta fatto e spostato sulla macchina, lasciandomi molto distratto quando potrebbe esserci una soluzione più diretta per cominciare

Per userbuild di progettazione di Android (questo è quello che hai sul tuo telefono fino a quando non sblocchi il bootloader e fai lampeggiare il telefono con userdebugo il engsoftware) limita l'accesso alla memoria interna : ogni app può accedere solo ai propri file. Fortunatamente per gli sviluppatori di software che non desiderano eseguire il root dei loro telefoni, Google fornisce un modo per accedere alla memoria interna delle versioni debuggabili dei loro pacchetti utilizzando il run-ascomando.

Per scaricare /data/data/debuggable.app.package.name/databases/fileda un dispositivo Android 5.1+ eseguire il seguente comando:

adb exec-out run-as debuggable.app.package.name cat databases/file > file

Per scaricare più file in una cartella sotto /data/data/debuggable.app.package.name/contemporaneamente, utilizzare tar:

adb exec-out run-as debuggable.app.package.name tar c databases/ > databases.tar
adb exec-out run-as debuggable.app.package.name tar c shared_prefs/ > shared_prefs.tar

La risposta accettata non funziona più per me (bloccato da Android?)

Quindi invece ho fatto questo:

> adb shell
shell $ run-as com.example.package
shell $ chmod 666 databases/file
shell $ exit                                               ## exit out of 'run-as'
shell $ cp /data/data/package.name/databases/file /sdcard/
shell $ run-as com.example.package
shell $ chmod 600 databases/file
> adb pull /sdcard/file .

Se qualcuno cerca di estrarre il database dall'applicazione di debug può utilizzare la procedura seguente:

1. cerca e apri Esplora file del dispositivo

2. Seleziona il tuo telefono e poi naviga nella data/datarubrica

3. Ora trova il pacchetto dell'applicazione e vai alla cartella dei database. Puoi vedere i database lì e, facendo clic con il tasto destro, avrai l'opzione per salvarlo nel tuo disco.

Ho pubblicato un semplice script di shell per il dumping dei database:

https://github.com/Pixplicity/humpty-dumpty-android

Esegue due metodi distinti descritti qui:

1. Innanzitutto, cerca di rendere il file accessibile ad altri utenti e tenta di estrarlo dal dispositivo.
2. Se fallisce, trasmette il contenuto del file sul terminale alla macchina locale. Esegue un trucco aggiuntivo per rimuovere i \rcaratteri che alcuni dispositivi inviano alla shell.

Da qui è possibile utilizzare una varietà di applicazioni CLI o GUI SQLite, come sqlite3o sqlitebrowser, per esplorare i contenuti del database.

Non riuscivo a far funzionare nient'altro per me ma questo:

adb shell
run-as package.name
cat /databases/databaseFileName.db > /sdcard/copiedDatabaseFileName.db
exit
exit
adb pull /sdcard/copiedDatabaseFileName.db /file/location/on/computer/

La prima uscita è uscire dal run-as, la seconda uscita è uscire dalla shell adb per eseguire il pull.

Per la versione di debug dell'app, è molto comodo usare il comando adb exec-out run-as xxx.yyy.zzz cat somefile > somefileper estrarre un singolo file. Ma devi farlo più volte per più file. Ecco un semplice script che utilizzo per estrarre la directory.

#!/bin/bash
P=
F=
D=

function usage()
{
    echo "$(basename $0) [-f file] [-d directory] -p package"
    exit 1
}

while getopts ":p:f:d:" opt
do
    case $opt in
        p)
            P=$OPTARG
            echo package is $OPTARG
            ;;
        f)
            F=$OPTARG
            echo file is $OPTARG
            ;;
        d)
            D=$OPTARG
            echo directory is $OPTARG
            ;;
        \?)
            echo Unknown option -$OPTARG
            usage
            ;;
        \:)
            echo Required argument not found -$OPTARG
            usage
            ;;
    esac
done

[ x$P == x ] && {
    echo "package can not be empty"
    usage
    exit 1
}

[[ x$F == x  &&  x$D == x ]] && {
    echo "file or directory can not be empty"
    usage
    exit 1
}

function file_type()
{
    # use printf to avoid carriage return
    __t=$(adb shell run-as $P "sh -c \"[ -f $1 ] && printf f || printf d\"")
    echo $__t
}

function list_and_pull()
{
    t=$(file_type $1)
    if [ $t == d ]; then
        for f in $(adb shell run-as $P ls $1)
        do
            # the carriage return output from adb shell should
            # be removed
            mkdir -p $(echo -e $1 |sed $'s/\r//')
            list_and_pull $(echo -e $1/$f |sed $'s/\r//')
        done
    else
        echo pull file $1
        [ ! -e $(dirname $1) ] && mkdir -p $(dirname $1)
        $(adb exec-out run-as $P cat $1 > $1)
    fi
}

[ ! -z $D ] && list_and_pull $D
[ ! -z $F ] && list_and_pull $F

Spero possa essere utile. Questo script è disponibile anche su Gist .

L'utilizzo tipico è

$ ./exec_out.sh -p com.example.myapplication -d databases

quindi estrarrà tutti i file nella directory dei database delle app, ovvero /data/data/com.example.myapplication/databasesnella directory corrente.

Approccio molto più semplice per scaricare il file sul tuo computer locale:

Nella shell del tuo PC esegui:

adb -d shell 'run-as <package_name> cat /data/data/<package_name>/databases/<db_name>' > <local_file_name>

#!/bin/bash
#export for adb
export PATH=$PATH:/Users/userMe/Library/Android/sdk/platform-tools
export PATH=$PATH:/Users/userMe/Library/Android/sdk/tools

adb -d shell 'run-as com.android.app  cp /data/data/com.android.app/files/db.realm /sdcard'
adb pull sdcard/db.realm /Users/userMe/Desktop/db

Puoi utilizzare questo script per ottenere il database Realm.

Se qualcuno sta cercando un'altra risposta che può essere utilizzata per recuperare Databasee Shared Preferencespoi seguire questo passaggio:

Nel build.gradlefile della tua app aggiungi una riga

debugCompile "com.amitshekhar.android:debug-db:1.0.0"

ora quando esegui la tua app in non-releasemodalità, la tua app aprirà automaticamente la porta 8080 dal tuo dispositivo IP addressassicurati che il tuo dispositivo sia connesso tramite wifie che tu laptopstia condividendo la stessa rete. Ora visita semplicemente l'URL

http: // your_mobile_device_ip: 8080 /

per guardare tutti i dati del database insieme alle preferenze condivise.

Ecco una soluzione che funziona su un dispositivo con Android 5.1. Il seguente esempio è per Windows.

Hai bisogno di sed (o sed.exe su Windows, ad esempio da cygwin.) (Su Unix, sarà solo lì;)). Per rimuovere i caratteri "\ r" cattivi, almeno su Windows.

Ora esegui il seguente comando:

adb exec-out "run-as com.yourcompany.yourapp /data/data/com.yourcompany.yourapp/databases/YourDatabaseName" | c:\cygwin\bin\sed.exe 's/\x0D\x0A/\x0A/'>YourDatabaseName.db

Il comando sed rimuove i caratteri / r finali.

Ovviamente dovresti sostituire "com.yourcompany.yourapp" con il nome del pacchetto dell'app e "YourDatabaseName" con il nome del database nell'app.

Il file di database è vuoto quando si utilizza adb run-as. Questo può essere risolto chiamando close () sull'istanza RoomDatabase. Chiama close () per consentire a SQLite di scrivere il suo journal su disco. Ho creato questo pulsante che chiude la connessione al database su richiesta:

tramite GIPHY

Ecco come chiamare close sull'istanza RoomDatabase.