Wie zeige ich die SQLite-Datenbank auf einem Android-Gerät an?

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.

1. Verbinden Sie Ihr Gerät und starten Sie die Anwendung im Debug-Modus.

2. 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.

3. 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

4. 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.

5. Installieren Sie Firefox SQLite Manager: https://addons.mozilla.org/en-US/firefox/addon/sqlite-manager/

6. Öffnen Sie Firefox SQLite Manager (Tools-> SQLite Manager) und öffnen Sie Ihre Datenbankdatei aus Schritt 3 oben.

7. Genießen!

Aus hier genommen, können Sie Folgendes versuchen:

1. Facebooks Open Source Stetho-Bibliothek

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. 

2. Eine weitere Option ist dieses Plugin (nicht frei)
3. Und die letzte ist diese Free/Open Source-Bibliothek, um den Inhalt der Datenbank im Browser anzuzeigen https://github.com/amitshekhariitbhu/Android-Debug-Database

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:

1. adb Shell
2. cd /go/to/databases
3. sqlite3 database.db
4. Geben Sie in der Eingabeaufforderung sqlite>.tables ein. Dadurch erhalten Sie alle Tabellen in der Datei database.db.
5. 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!

• Es ist nicht notwendig, dass Ihr Gerät ROOTIERT wird
• Die Datenbankdatei der Anwendung muss nicht importiert werden
• Wenige Konfigurationen und du bist gut zu gehen!

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:

https://github.com/Pixplicity/dbdump

Es führt zwei verschiedene hier beschriebene Methoden aus:

1. Zunächst wird versucht, die Datei für andere Benutzer zugänglich zu machen, und versucht, sie vom Gerät abzurufen.
2. Wenn dies fehlschlägt, werden die Inhalte der Datei über das Terminal an den lokalen Computer übertragen. Es führt einen zusätzlichen Trick aus, um \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.

https://github.com/facebook/stetho

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.

1. Kopieren Sie das Skript mit adb in das Verzeichnis (z. B.: ~/Android-sdk/platform-tools).
2. Gerät muss an PC angeschlossen sein.
3. Verwenden Sie ./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.