Ich habe einen Datensatz in einer SQLite-Datenbank. Ich muss die Datenbank auf einem Gerät anzeigen. Wie mache ich das?
Ich habe im DDMS-Modus überprüft. Die Daten im Datei-Explorer sind leer.
Hier sind Schritt-für-Schritt-Anweisungen (meistens aus einer Kombination der anderen Antworten entnommen). Dies funktioniert auch auf Geräten, die nicht gerootet sind.
Verbinden Sie Ihr Gerät und starten Sie die Anwendung im Debug-Modus.
Möglicherweise möchten Sie adb -d Shell "run-as com.yourpackge.name ls /data/data/com.yourpackge.name/databases/"
verwenden, um den Dateinamen der Datenbank anzuzeigen.
Notice:com.yourpackge.name
ist der Name Ihres Anwendungspakets. Sie können es aus der Manifest-Datei erhalten.
Kopieren Sie die Datenbankdatei aus Ihrem Anwendungsordner auf Ihre SD-Karte.
adb -d Shell "run-as com.yourpackge.name cat /data/data/com.yourpackge.name/databases/filename.sqlite > /sdcard/filename.sqlite"
Notice: Dateiname.sqlite ist Ihr Datenbankname, den Sie beim Erstellen der Datenbank verwendet haben
Ziehen Sie die Datenbankdateien auf Ihren Computer:
adb pull /sdcard/filename.sqlite
Dadurch wird die Datenbank von der SD-Karte an den Ort kopiert, an dem sich Ihre ADB befindet.
Installieren Sie Firefox SQLite Manager: https://addons.mozilla.org/en-US/firefox/addon/sqlite-manager/
Öffnen Sie Firefox SQLite Manager (Tools-> SQLite Manager) und öffnen Sie Ihre Datenbankdatei aus Schritt 3 oben.
Genießen!
Aus hier genommen, können Sie Folgendes versuchen:
In build.gradle:
dependencies {
// Stetho core
compile 'com.facebook.stetho:stetho:1.5.0'
//If you want to add a network helper
compile 'com.facebook.stetho:stetho-okhttp:1.5.0'
}
Initialisieren Sie die Bibliothek im Anwendungsobjekt:
Stetho.initializeWithDefaults(this);
Sie können Ihre Datenbank in Chrome über chrome://inspect
anzeigen.
Der beste Weg, den ich bisher gefunden habe, ist das Android-Debug-Datenbank-Tool.
Es ist unglaublich einfach zu bedienen und einzurichten. Fügen Sie einfach die Abhängigkeit hinzu und stellen Sie über das Web eine Verbindung zur Schnittstelle der Gerätedatenbank her. Sie müssen das Telefon nicht rooten oder Aktivitäten hinzufügen oder was auch immer. Hier sind die Schritte:
SCHRITT 1
Fügen Sie der Gradle-Datei Ihrer App die folgende Abhängigkeit hinzu und führen Sie die Anwendung aus.
debugCompile 'com.amitshekhar.Android:debug-db:1.0.0'
SCHRITT 2
Öffnen Sie Ihren Browser und besuchen Sie die IP-Adresse Ihres Telefons an Port 8080. Die URL sollte wie folgt aussehen: http://YOUR_PHONE_IP_ADDRESS:8080
. Sie erhalten Folgendes:
HINWEIS: Sie können die URL der Debug-Adresse auch immer aus Ihrem Code abrufen, indem Sie die Methode DebugDB.getAddressLog();
aufrufen.
Um die IP-Adresse meines Telefons zu erhalten, verwende ich derzeit Ping-Tools. Es gibt jedoch viele Alternativen.
SCHRITT 3
Das ist es!
Weitere Details in der offiziellen Dokumentation: https://github.com/amitshekhariitbhu/Android-Debug-Database
Die beste Möglichkeit, Ihre Android-App-Datenbank anzuzeigen und zu verwalten, ist die Verwendung der Bibliothek DatabaseManager_For_Android .
Es ist eine einzelne Java-Aktivitätsdatei. Fügen Sie es einfach zu Ihrem Quellordner hinzu. Sie können die Tabellen in Ihrer App-Datenbank anzeigen, aktualisieren, löschen und Zeilen in Ihre Tabelle einfügen. Alles aus Ihrer App heraus.
Wenn die Entwicklung abgeschlossen ist, entfernen Sie die Java-Datei aus Ihrem SRC-Ordner. Das ist es.
Sie können die 5-Minuten-Demo Database Manager für Android SQLite Database anzeigen.
Du kannst das:
adb Shell
cd /go/to/databases
sqlite3 database.db
sqlite>
.tables
ein. Dadurch erhalten Sie alle Tabellen in der Datei database.db.select * from table1;
Wenn Sie ein echtes Gerät verwenden, das nicht verwurzelt ist, können Sie Ihre Datenbank nicht in FileExplorer
anzeigen, da der Ordner aus Sicherheitsgründen im Android-System gesperrt ist. Wenn Sie es in einem Emulator verwenden, finden Sie es in FileExplorer
,/data/data/Ihren Paketnamen/database/yourdatabse.db .
Probieren Sie AndroidDBvieweR!
Ich habe SQLite Database Browser verwendet, um den Inhalt der SQLite-Datenbank in der Android-Entwicklung zu sehen. Sie müssen zuerst die Datenbankdatei aus dem Gerät ziehen und sie dann in SQLite DB Browser öffnen.
Obwohl die Datenbank nicht direkt auf Ihrem Gerät angezeigt wird, habe ich ein einfaches Shell-Skript zum Ablegen von Datenbanken auf Ihrem lokalen Computer veröffentlicht:
Es führt zwei verschiedene hier beschriebene Methoden aus:
\r
-Zeichen zu entfernen, die einige Geräte an die Shell ausgeben.Von hier aus können Sie eine Vielzahl von CLI- oder GUI-SQLite-Anwendungen verwenden, z. B. sqlite3
oder sqlitebrowser
, um den Inhalt der Datenbank zu durchsuchen.
step 1Kopieren Sie diese Klasse in Ihr Paket
Schritt 2 Fügen Sie den folgenden Code in Ihre Klasse ein, der SQLiteOpenHelper erweitert.
//-----------------for show databasae table----------------------------------------
public ArrayList<Cursor> getData(String Query)
{
//get writable database
SQLiteDatabase sqlDB =this.getWritableDatabase();
String[] columns = new String[] { "mesage" };
//an array list of cursor to save two cursors one has results from the query
//other cursor stores error message if any errors are triggered
ArrayList<Cursor> alc = new ArrayList<Cursor>(2);
MatrixCursor Cursor2= new MatrixCursor(columns);
alc.add(null);
alc.add (null);
try{
String maxQuery = Query ;
//execute the query results will be save in Cursor c
Cursor c = sqlDB.rawQuery(maxQuery, null);
//add value to cursor2
Cursor2.addRow(new Object[] { "Success" });
alc.set(1,Cursor2);
if (null != c && c.getCount() > 0)
{
alc.set(0,c);
c.moveToFirst();
return alc ;
}
return alc;
}
catch(SQLException sqlEx)
{
Log.d("printing exception", sqlEx.getMessage());
//if any exceptions are triggered save the error message to cursor an return the arraylist
Cursor2.addRow(new Object[] { ""+sqlEx.getMessage() });
alc.set(1,Cursor2);
return alc;
}
catch(Exception ex)
{
Log.d("printing exception",ex.getMessage());
//if any exceptions are triggered save the error message to cursor an return the arraylist
Cursor2.addRow(new Object[] { ""+ex.getMessage() });
alc.set(1,Cursor2);
return alc;
}
}
Schritt 3 Im Manifest registrieren
<activity
Android:name=".database.AndroidDatabaseManager"
Android:screenOrientation="portrait"
Android:theme="@style/AppTheme.NoActionBar"/>
Schritt 4
Intent i = new Intent(this, AndroidDatabaseManager.class);
startActivity(i);
versuchen Sie es mit Facebook Stetho.
Stetho ist eine Debug-Bridge für Android-Anwendungen, die die leistungsstarken Chrome Developer Tools und vieles mehr unterstützt.
Folge diesen Schritten
1> Laden Sie die * .jar-Datei von hier herunter.
2> Legen Sie die * .jar-Datei in den Ordner Eclipse/dropins/und starten Sie Eclipse neu.
3> Klicken Sie oben rechts in Eclipse auf das DDMS-Symbol.
4> Wählen Sie im linken Bedienfeld den richtigen Emulator aus.
5 Wechseln Sie auf der Registerkarte Datei-Explorer im Hauptfenster zu /data/data/[YOUR.APP.NAMESPACE/Datendatenbanken.
6> Unter dem DDMS-Symbol sollte ein neues blaues Symbol für eine Datenbank leuchten, wenn Sie Ihre Datenbank auswählen. Klicken Sie darauf und Sie werden sehen, dass eine Questoid Sqlite Manager-Registerkarte geöffnet wird, um Ihre Daten anzuzeigen.
* Hinweis: Wenn die Datenbank nicht aufleuchtet, liegt dies möglicherweise daran, dass Ihre Datenbank keine * .db-Dateierweiterung hat. Stellen Sie sicher, dass Ihre Datenbank [DATABASE_NAME] .db heißt
* Hinweis: Wenn Sie eine DB ohne .db-Erweiterung verwenden wollen:
-Dieses Questoid SqLiteBrowser herunterladen: Hier herunterladen .
-Unzip und lege es in Eclipse/dropins (nicht Plugins).
- Weitere Informationen finden Sie hier Hier klicken .
Dies funktioniert mit Android 6.0 (mindestens debuggbare Apps):
adb Shell "run-as your.package.name cp /data/data/your.package.name/databases/you-db-name /sdcard/file_to_write"
Dann können Sie die Datenbank beispielsweise einfach mit aSQLiteManager anzeigen.
Hoffe das hilft dir
Verwenden des Terminals Zuerst legen Sie fest, wo sich andriod sdk befindet
eg: C:\Users\AppData\Local\Android\sdk\platform-tools>
Überprüfen Sie dann die Liste der angeschlossenen Geräte
adb devices
führen Sie dann diesen Befehl aus, um die Datei vom Gerät auf Ihr System zu kopieren
adb -s YOUR_DEVICE_ID Shell run-as YOUR_PACKAGE_NAME chmod -R 777 /data/data/YOUR_PACKAGE_NAME/databases && adb -s YOUR_DEVICE_ID Shell "mkdir -p /sdcard/tempDB" && adb -s YOUR_DEVICE_ID Shell "cp -r /data/data/YOUR_PACKAGE_NAME/databases/ /sdcard/tempDB/." && adb -s YOUR_DEVICE_ID pull sdcard/tempDB/ && adb -s YOUR_DEVICE_ID Shell "rm -r /sdcard/tempDB/*"
Sie finden die Datenbankdatei in diesem Pfad
Android\sdk\platform-tools\tempDB\databases
Sie können SQLiteOnWeb versuchen. Es verwaltet Ihre SQLite-Datenbank im Browser.
Es gibt den Android SQLite-Browser von TKlerx für Eclipse, der neben Android Studio voll funktionsfähig ist. Ich werde es empfehlen, weil es sehr praktisch ist.
Um sie auf dem Device Monitor zu installieren, platzieren Sie die JAR-Datei einfach in [Path to Android SDK folder]/sdk/tools/lib/monitor-[...]/plugins
.
Ich fand sehr einfache Bibliothek Stetho zum Durchsuchen von sqlite db App in Chrom, siehe
Erster Beitrag ( https://stackoverflow.com/a/21151598/4244605 ) funktioniert bei mir nicht.
Ich habe ein eigenes Skript geschrieben, um eine DB-Datei vom Gerät abzurufen. Ohne wurzel Funktioniert OK.
~/Android-sdk/platform-tools
)../getDB.sh -p <packageName>
, um den Namen der Datenbanken abzurufen.Verwendung: ./getDB.sh -p <packageName> -n <name of DB> -s <store in mobile device>
für die DB-Datei in dieses Verzeichnis (in dem das Skript ausgeführt wird).
Ich empfehle, den Dateinamen der Datenbank als * .sqlite festzulegen und ihn mit dem Firefox-Addon: SQLite Manager zu öffnen.
(Es ist eine lange Zeit, wenn ich etwas in Bash geschrieben habe. Sie können diesen Code bearbeiten.)
#!/bin/sh
# Get DB from Android device.
#
Hoption=false
Poption=false
Noption=false
Soption=false
Parg=""
Narg=""
Sarg=""
#-----------------------FUNCTION--------------------------:
helpFunc(){ #help
echo "Get names of DB's files in your Android app.
Usage: ./getDB -h
./getDB -p packageName -n nameOfDB -s storagePath
Options:
-h Show help.
-p packageName List of databases for package name.
-p packageName -n nameOfDB -s storagePath Save DB from device to this directory."
}
#--------------------------MAIN--------------------------:
while getopts 'p:n:s:h' options; do
case $options in
p) Poption=true
Parg=$OPTARG;;
n) Noption=true
Narg=$OPTARG;;
s) Soption=true
Sarg=$OPTARG;;
h) Hoption=true;;
esac
done
#echo "-------------------------------------------------------
#Hoption: $Hoption
#Poption: $Poption
#Noption: $Noption
#Soption: $Soption
#Parg: $Parg
#Narg: $Narg
#Sarg: $Sarg
#-------------------------------------------------------"\\n
#echo $# #count of params
if [ $Hoption = true ];then
helpFunc
Elif [ $# -eq 2 -a $Poption = true ];then #list
./adb -d Shell run-as $Parg ls /data/data/$Parg/databases/
exit 0
Elif [ $# -eq 6 -a $Poption = true -a $Noption = true -a $Soption = true ];then #get DB file
#Change permissions
./adb Shell run-as $Parg chmod 777 /data/data/$Parg/databases/
./adb Shell run-as $Parg chmod 777 /data/data/$Parg/databases/$Narg
#Copy
./adb Shell cp /data/data/$Parg/databases/$Narg $Sarg
#Pull file to this machine
./adb pull $Sarg/$Narg
exit 0
else
echo "Wrong params or arguments. Use -h for help."
exit 1;
fi
exit 0;
Mit dem Datei-Explorer können Sie Ihre Datenbankdatei folgendermaßen finden:
data-->data-->your.package.name-->databases--->yourdbfile.db
Dann können Sie jede Frontseite von SQLite verwenden, um Ihre Datenbank zu durchsuchen. Ich benutze das SQLite Manager Firefox Addon. Es ist nett, klein und schnell.