Simple ToDo App mit WebSQL

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    • Simple ToDo App mit WebSQL

      ToDo App

      cordova-forum.de/index.php?att…72067f2379ae7ed6dcb72b18c

      Die „ToDo-App“ ist eine simple Anwendung, welche es ermöglicht, sich eine eigene ToDo-Liste zu erstellen.Zum besserem Verständnis wurde die Anwendung in mehrere Dateien aufgeteilt.Die Datei “database.js” enthält alle Funktionen um die WebSQL-Datenbank zu erstellen, bzw. zu verwalten. Die Datei “ui.js” verfügt über alle Funktionen um Daten auf der Benutzeroberfläche zu manipulieren. Des Weiteren dient sie als Schnittstelle zwischen der Datenbank und der Benutzeroberfläche. Und als letztes bleibt noch die Datei “index.html”. Sie repräsentiert die eigentliche Benutzeroberfläche und ist dafür verantwortlich, die gespeicherten Daten anzuzeigen, bzw. eine Möglichkeit zu schaffen, neue Daten einzugeben.

      Benutzeroberfläche

      Um die Umsetzung der Benutzeroberfläche einfach zu halten, wurde das bekannte UI-Framework„bootstrap“ verwendet. Dieses Framework hat den Vorteil, dass sich mit ihm einfache Oberflächen gestalten lassen, welche auf verschiedenen Displays sehr gut skalieren.

      Da der Fokus in diesem Tutorial auf der Datenbank liegt, ist der Aufbau des User-Interfaces sehr simpel gehalten. Es besteht aus einem Eingabefeld, einem Button und einer Liste. Das Eingabefeld dient dazu, den Namen der Aufgabe anzugeben. Mittels des Buttons kann dann die Aufgabe der Datenbank hinzugefügt werden. Die gespeicherten Aufgaben werden daraufhin in der Liste dargestellt. Jedes Listenelement verfügt am rechten Rand über ein „X“. Über dieses lässt sich die Aufgabe aus der Liste und damit auch aus der Datenbank entfernen.

      Zusätzlich zu den oben genannten Elementen, gibt es „Alerts“. Diese werden dazu verwendet, dem Benutzer eine Rückmeldung von der Tätigkeit der Anwendung zu geben.

      cordova-forum.de/index.php?att…72067f2379ae7ed6dcb72b18c

      Code der Datei „index.html“:

      HTML-Quellcode

      1. <!doctype html>
      2. <html>
      3. <head>
      4. <meta charset="utf-8">
      5. <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no">
      6. <title>ToDo App with WebSQL</title>
      7. <link rel="stylesheet" href="libs/bootstrap/3.3.4/css/bootstrap.min.css">
      8. <link rel="stylesheet" href="libs/bootstrap/3.3.4/css/bootstrap-theme.min.css">
      9. <link rel="stylesheet" href="css/style.css">
      10. </head>
      11. <body>
      12. <div class="container">
      13. <div class="row">
      14. <div class="col-md-12 header">
      15. <div class="text-center text-uppercase">
      16. ToDo App mit WebSQL
      17. </div>
      18. </div>
      19. </div>
      20. <div class="content row">
      21. <div class="col-md-12">
      22. <div class="form-group">
      23. <div class="input-group">
      24. <div class="input-group-addon"><span class="glyphicon glyphicon-tags" aria-hidden="true"></span></div>
      25. <input type="text" class="form-control" id="new_task" placeholder="Neue Aufgabe">
      26. </div>
      27. </div>
      28. <button type="button" class="btn btn-default" onclick="ui.add_new_task()">
      29. hinzufügen
      30. </button>
      31. </div>
      32. </div>
      33. <div class="task row">
      34. <div class="col-md-12">
      35. <div class="list-group" id="task_list"><!-- Liste mit den Aufgaben --></div>
      36. </div>
      37. </div>
      38. <div class="msg row"><!-- Rückmeldung an den Bentuzer --></div>
      39. </div><!-- end container -->
      40. <!-- JAVASCRIPT -->
      41. <script src="libs/jquery/2.1.3/jquery-2.1.3.min.js"></script>
      42. <script src="js/database.js"></script>
      43. <script src="js/ui.js"></script>
      44. <script>
      45. $( document ).ready(function() {
      46. // öffent die Datenbank
      47. // und legt die Tablle "task" an wenn diese nicht schon besteht
      48. database.initialize();
      49. // Liest alle Aufagen aus der Datenbank und zeigt sie an
      50. ui.get_all_task();
      51. });
      52. </script>
      53. </body>
      54. </html>
      Alles anzeigen


      Schnittstelle zwischen UI und Datenbank

      Als Verbindung zwischen der Benutzeroberfläche und der Datenbank dient die Datei „ui.js“. Die Funktionen „add_new_task“, „get_task“, „get_all_task“ und „del_task“ werden direkt aus der Benutzeroberfläche angesprochen. Sie dienen als Steuerung der Interaktionen mit der Datenbank. So fügt zum Beispiel die Funktion „add_new_task“ eine neue Aufgabe zur Datenbank hinzu.

      Neben diesen Funktionen enthält die Datei alle Callback-Funktionen für die Datenbankabfrage. Für jede Interaktion gibt es eine positive und eine negative Funktion. Die positive Funktion wird aufgerufen, wenn die Abfrage erfolgreich war und die negative wenn während der Abfrage ein Fehler aufgetreten ist.

      Da sowohl die positiven, als auch negativen Funktionen eine Aktion innerhalb der Benutzeroberfläche nach sich ziehen, ist es sinnvoll, die Callback-Funktionen aus der Datei „database.js“ auszulagern.

      Code der Datei „ui.js“:

      Quellcode

      1. "use strict";
      2. var ui =
      3. {
      4. duration: 2500, // 2500 ms => 2.5 seconds
      5. /**
      6. * Diese Funktion fügt eine neu eingeben Aufgabe der Datenbank hinzu
      7. *
      8. * @method add_new_task
      9. *
      10. */
      11. add_new_task: function()
      12. {
      13. var $new_task = $('#new_task');
      14. var value = $new_task.val();
      15. // keine leeren Einträge
      16. if( value.length > 0 )
      17. {
      18. $new_task.val(''); // Input-Feld leeren
      19. database.insert_task( value, this.succes_insert, this.error_insert );
      20. }
      21. else
      22. {
      23. ui.show_msg('alert-danger', '<strong>Fehler!</strong> Es werden keine leeren Aufgaben gespeichert.' );
      24. }
      25. },
      26. /**
      27. * Callback für das Erfolgreiche eintragen einer neuen Aufgabe
      28. *
      29. * @method succes_insert
      30. * @param {Object} tx
      31. * @param {Oject} results Ergebnis der Datenabfrage
      32. */
      33. succes_insert: function( tx, results )
      34. {
      35. ui.get_all_task(); // Aktualisiert die Oberfläche
      36. },
      37. /**
      38. * Callback für den Fehlerfall beim eintragen einer neuen Aufgabe
      39. *
      40. * @method error_insert
      41. * @param {Object} tx
      42. * @param {Oject} error Fehlermeldung
      43. */
      44. error_insert: function( tx, error )
      45. {
      46. ui.show_msg('alert-danger', '<strong>Fehler!</strong> Aufgabe konnte nicht gespeichert werden.' );
      47. },
      48. /**
      49. * Diese Funktion veranlasst die Datenbank eine bestimmte Aufgabe auszulesen
      50. *
      51. * @method get_task
      52. * @param {Number} task_id ID der Aufgabe
      53. */
      54. get_task: function( task_id )
      55. {
      56. database.select_task( task_id ,this.success_select, this.error_select );
      57. },
      58. /**
      59. * Diese Funktion veranlasst die Datenbank alle Aufgabe auszulesen
      60. *
      61. * @method get_all_task
      62. *
      63. */
      64. get_all_task: function()
      65. {
      66. database.select_all_task( this.success_select, this.error_select );
      67. },
      68. /**
      69. * Callback für das Erfolgreiche ermitteln der Daten der Aufgabe
      70. *
      71. * @method success_select
      72. * @param {Object} tx
      73. * @param {Oject} results Ergebnis der Datenabfrage
      74. */
      75. success_select: function( tx, results )
      76. {
      77. var len = results.rows.length;
      78. var tmp = '';
      79. for (var i = 0; i < len; i++)
      80. {
      81. var item = results.rows.item(i);
      82. tmp += '<a href="#" class="list-group-item clearfix" >';
      83. tmp += $.trim( item.task_name );
      84. tmp += '<span class="pull-right">';
      85. tmp += '<button class="btn btn-xs btn-danger" onclick="ui.del_task('+ item.task_id +')">';
      86. tmp += '<span class="glyphicon glyphicon-trash"></span>';
      87. tmp += '</button>';
      88. tmp += '</span>';
      89. tmp += '</a>';
      90. }
      91. $('#task_list').html( tmp );
      92. },
      93. /**
      94. * Callback für den Fehlerfall beim ermitteln der Daten der Aufgabe
      95. *
      96. * @method error_insert
      97. * @param {Object} tx
      98. * @param {Oject} error Fehlermeldung
      99. */
      100. error_select: function( tx, error )
      101. {
      102. ui.show_msg('alert-danger', '<strong>Fehler!</strong> Es konnte keine Aufgabe ausgewählt werden.' );
      103. },
      104. /**
      105. * Diese Funktion veranlasst die Datenbank eine bestimmte Aufgabe zu löschen
      106. *
      107. * @method del_task
      108. * @param {Number} task_id ID der Aufgabe
      109. */
      110. del_task: function( task_id )
      111. {
      112. task_id = parseInt( task_id );
      113. if( !isNaN( task_id ) && task_id > 0 )
      114. {
      115. database.delete_task( task_id, this.succes_delete, this.error_delete );
      116. }
      117. else
      118. {
      119. console.log( 'id is not a number or id is smaller then 0 -- function: del_task' );
      120. }
      121. },
      122. /**
      123. * Callback für das Erfolgreiche löschen einer Aufgabe
      124. *
      125. * @method succes_delete
      126. * @param {Object} tx
      127. * @param {Oject} results Ergebnis der Datenabfrage
      128. */
      129. succes_delete: function( tx, results )
      130. {
      131. ui.get_all_task(); // Oberfläche aktualisieren
      132. ui.show_msg('alert-success', '<strong>Erfolgreich!</strong> Aufgabe wurde gelöscht.' );
      133. },
      134. /**
      135. * Callback für den Fehlerfall beim löschen einer Aufgabe
      136. *
      137. * @method error_delete
      138. * @param {Object} tx
      139. * @param {Oject} error Fehlermeldung
      140. */
      141. error_delete: function( tx, error )
      142. {
      143. ui.show_msg('alert-danger', '<strong>Fehler!</strong> Aufgabe konnte nicht gelöscht werden.' );
      144. },
      145. /**
      146. * Diese Funktion gibt den Benutzer eine Rückmeldung in Form einer Nachricht
      147. *
      148. * @method show_msg
      149. * @param {String} kind Art der Nachricht
      150. * @param {String} msg Text der Nachricht
      151. */
      152. show_msg: function( kind, msg )
      153. {
      154. var $msg = $('.msg');
      155. $msg.html( '<div class="alert '+ kind +'" role="alert">' + msg + '</div>' );
      156. $msg.show();
      157. $msg.fadeOut( ui.duration );
      158. }
      159. }
      Alles anzeigen


      Datenbank

      Die Struktur der Datenbank ist sehr simpel gehalten – sie besteht nur aus einer Tabelle. In dieser Tabelle werden die einzelnen Aufgaben gespeichert. Um dies zu ermöglichen, enthält die Tabelle zwei Spalten. In der ersten befindet sich die ID der jeweiligen Aufgabe und in der zweiten der Name.

      ID
      Name
      1Müll rausbringen
      2Brötchen kaufen
      3Hausaufgaben machen
      4Game of Thrones schauen

      Darstellung der Tabelle mit 4 Beispiel-Datensätzen


      Google Developer Tools


      Um sich während der Entwicklung die Datenbank anzusehen, empfiehlt es sich, die im Chrome Browser enthaltenen Entwickler Tools zu verwenden. Die Tools lassen sich über den Punkt „Weitere Tools → Entwicklertools“ öffnen.

      cordova-forum.de/index.php?att…72067f2379ae7ed6dcb72b18c

      Wenn die Anwendung im Chrome Browser ausgeführt wurde, befindet sich unter dem Punkt „Ressources → WebSQL“ die Datenbank.

      cordova-forum.de/index.php?att…72067f2379ae7ed6dcb72b18c

      Sollte die eigentliche „Datenbank-Datei“ benötigt werden, findet man diese unter dem folgen Pfad auf seinem Computer:

      BetriebssystemPfad
      Win7
      C:\Users\%USERNAME%\AppData\Local\Google\Chrome\User Data\Default\databases
      Mac OS X
      ~/Library/Application Support/Google/Chrome/Default/databases
      Linux
      ~/.config/google-chrome/Default/databases


      openDatabase

      Um die Datenbank zu erstellen, wird aus der Datei „database.js“ die Funktion „initialize“ aufgerufen. Hierbei ist zu beachten, dass diese Funktion gleichzeitig zum Öffnen und Anlegen der Datenbank dient. Daher muss sie bei jedem Start der Anwendung aufgerufen werden. Innerhalb der Funktion„initialize“ wird die Funktion „openDatabase“ aufgerufen. Diese Funktion gehört zur WebSQL-Browser-API und übernimmt das eigentliche Anlegen bzw. Öffnen der Datenbank. Sie erhält als Parameter den Namen, die Versionsnummer, die Beschreibung und die Größe der Datenbank.

      Quellcode

      1. openDatabase( 'todo_app', '1.0', 'Todo App database', 512000 );


      transaction

      Nachdem dem erfolgreichen Öffnen der Datenbank, wird mit dem Aufruf der Funktion „transaction“ eine Transaktion auf sie ausgeführt. Eine Transaktion kann dabei eine oder mehrere SQL-Statements enthalten. Der große Vorteil von Transaktionen ist, dass sie die Möglichkeit eines „rollback“ bieten. Ein „rollback“ bedeutet, dass wenn ein SQL-Statement innerhalb der Transaktion fehlschlägt, die komplette Transaktion zurückgesetzt wird.

      In dem folgenden Beispiel soll dieses Verhalten demonstriert werden. Als erstes wird eine neue Datenbank angelegt und dann in dieser die Tabelle „Produkte“ eingefügt. Innerhalb der Tabelle sollen nun zwei „Artikel“ mit der gleichen „Artikelnummer“ eingetragen werden.

      Quellcode

      1. var db = openDatabase( 'Katalog', '1.0', 'Katalog datenbank', 512000 );
      2. db.transaction(
      3. function(tx) {
      4. tx.executeSql( 'CREATE TABLE Produkte ( Artikelnr UNIQUE, Artikelname TEXT )' );
      5. tx.executeSql( 'INSERT INTO Produkte ( Artikelnr, Artikelname ) VALUES ( ? , ? )', [ '111', 'Xbox One' ] );
      6. tx.executeSql( 'INSERT INTO Produkte ( Artikelnr, Artikelname ) VALUES ( ? , ? )', [ '111', 'Playstation 4' ] );
      7. },
      8. function( error )
      9. {
      10. console.log( "FEHLER" );
      11. console.log( error );
      12. },
      13. function()
      14. {
      15. console.log( "SUCCES" );
      16. }
      17. );
      Alles anzeigen


      Nach Ausführen dieses Beispiels sollte weder die Tabelle angelegt, noch die Zeilen eingetragen worden sein. Kontrollieren kann man das zum Beispiel, indem man die Datenbank in den Chrome Developer Tools öffnet.

      cordova-forum.de/index.php?att…72067f2379ae7ed6dcb72b18c

      Wird das Beispiel aber nun so verändert, dass die „Artikel“ nicht die gleiche „Artikelnummer“besitzen, wird in den Developer Tools die neue Tabelle angezeigt.

      cordova-forum.de/index.php?att…72067f2379ae7ed6dcb72b18c

      Die Funktion „transaction“ hat nur einen Pflichtparameter – der Callback für SQLTransaction. Die beiden Callbacks für den Fehler- bzw. Success-Fall sind rein optional und können somit auch vernachlässigt werden.

      executeSql

      Der SQLTransaction Callback erhält als Parameter ein SQLTranscation Objekt. Dieses Objekt verfügt über die Methode „executeSql“. Mit dieser können sowohl lesende, als auch schreibende SQL-Statements ausgeführt werden. Als ersten Parameter erhält die Funktion das SQL-Statement, welches ausgeführt werden soll. Der zweite Parameter ist ein Array mit den möglichen Argumenten innerhalb des SQL-Statements. Der dritte und vierte Parameter sind die Callbacks für den Fehler- bzw. Success-Fall.

      Wie bereits bei der Funktion „transaction“ erläutert, ist nur der erste Parameter ein Pflichtparameter und alle anderen sind optional.

      Hinweis: Sollten dem SQL-Statement Argumente übergeben werden, sind diese niemals direkt im SQL-Statement anzugeben. In diesem Fall immer den „?“-Platzhalter im SQL-Statement verwenden! Die Argumente können daraufhin als Array der Funktion „executeSql“ übergeben werden. Diese ersetzt dann die „?“-Platzhalter eigenständig durch die Argumente. Die Reihenfolge wird dabei durch die Reihenfolge der Elemente im Array bestimmt.

      Code der Datei „database.js“:

      Quellcode

      1. "use strict";
      2. var database =
      3. {
      4. db: null,
      5. /**
      6. * Konstruktor
      7. * Wenn noch keine Datenbakn vorhanden ist wird sie erst angelegt und zum lesen/schreiben geöffent
      8. * Sollte die Databank schon bestehen wird sie zum lesen/schreiben geöffnet
      9. *
      10. * @method initialize
      11. */
      12. initialize: function()
      13. {
      14. /*
      15. Parameter:
      16. 1. Name der Datenbank
      17. 2. Versionsnummer
      18. 3. Beschreibung
      19. 4. Größe der Datenbank
      20. */
      21. this.db = openDatabase( 'todo_app', '1.0', 'Todo App database', 512000 );
      22. if( this.db != null )
      23. {
      24. this.db.transaction(
      25. function(tx) {
      26. tx.executeSql( 'CREATE TABLE IF NOT EXISTS task ( task_id INTEGER PRIMARY KEY, task_name TEXT )', [], database.on_succes, database.on_error );
      27. }
      28. );
      29. }
      30. },
      31. /**
      32. * Diese Funktion fügt eine neue Aufgabe der Taballe task hinzu
      33. *
      34. * @method insert_task
      35. * @param {String} task Aufgabe die eingetragen werden soll
      36. * @param {Function} succes_callback Callback der aufgerufen wird wenn die Interaktion mit der Datenbank erfolgreich war
      37. * @param {Function} error_callback Callback der aufgerufen wird wenn ein Fehler in Datenbankabfrage auftritt
      38. */
      39. insert_task: function( task, succes_callback, error_callback )
      40. {
      41. if( this.db != null )
      42. {
      43. this.db.transaction(
      44. function(tx) {
      45. tx.executeSql('INSERT INTO task ( task_name ) VALUES ( ? )', [ $.trim( task ) ], succes_callback, error_callback );
      46. }
      47. );
      48. }
      49. else
      50. {
      51. console.log( 'database is close -- function: insert_task' );
      52. }
      53. },
      54. /**
      55. * Diese Funktion liest alle Aufgaben aus der Datenbank
      56. *
      57. * @method select_all_task
      58. * @param {Function} succes_callback Callback der aufgerufen wird wenn die Interaktion mit der Datenbank erfolgreich war
      59. * @param {Function} error_callback Callback der aufgerufen wird wenn ein Fehler in Datenbankabfrage auftritt
      60. */
      61. select_all_task: function( succes_callback, error_callback )
      62. {
      63. if( this.db != null )
      64. {
      65. this.db.transaction(
      66. function(tx) {
      67. tx.executeSql('SELECT * FROM task', [], succes_callback, error_callback );
      68. }
      69. );
      70. }
      71. else
      72. {
      73. console.log( 'database is close -- function: select_all_task' );
      74. }
      75. },
      76. /**
      77. * Diese Funktion liest eine bestimmte Aufgabe aus der Datenbank
      78. *
      79. * @method select_task
      80. * @param {Number} task_id Die ID der Aufgabe
      81. * @param {Function} succes_callback Callback der aufgerufen wird wenn die Interaktion mit der Datenbank erfolgreich war
      82. * @param {Function} error_callback Callback der aufgerufen wird wenn ein Fehler in Datenbankabfrage auftritt
      83. */
      84. select_task: function( task_id, succes_callback, error_callback )
      85. {
      86. if( this.db != null )
      87. {
      88. task_id = parseInt(task_id);
      89. if( !isNaN( task_id ))
      90. {
      91. this.db.transaction(
      92. function(tx) {
      93. tx.executeSql('SELECT * FROM task WHERE task_id = ? ', [ task_id ], succes_callback, error_callback );
      94. }
      95. );
      96. }
      97. else
      98. {
      99. console.log( 'id is not a number -- function: select_task' );
      100. }
      101. }
      102. else
      103. {
      104. console.log( 'database is close -- function: select_task' );
      105. }
      106. },
      107. /**
      108. * Diese Funktion löscht eine bestimmte Aufgabe aus der Datenbank
      109. *
      110. * @method delete_task
      111. * @param {Number} task_id Die ID der Aufgabe
      112. * @param {Function} succes_callback Callback der aufgerufen wird wenn die Interaktion mit der Datenbank erfolgreich war
      113. * @param {Function} error_callback Callback der aufgerufen wird wenn ein Fehler in Datenbankabfrage auftritt
      114. */
      115. delete_task: function( task_id, succes_callback, error_callback )
      116. {
      117. if( this.db != null )
      118. {
      119. task_id = parseInt(task_id);
      120. if( !isNaN( task_id ))
      121. {
      122. this.db.transaction(
      123. function(tx) {
      124. tx.executeSql('DELETE FROM task WHERE task_id = ? ', [ task_id ], succes_callback, error_callback );
      125. }
      126. );
      127. }
      128. else
      129. {
      130. console.log( 'task id is not a number -- function: delete_task' );
      131. }
      132. }
      133. else
      134. {
      135. console.log( 'database is close -- function: delete_task' );
      136. }
      137. },
      138. /**
      139. * Allgemeiner Callback für den Fehlerfall
      140. *
      141. * @method on_error
      142. */
      143. on_error: function( tx, error )
      144. {
      145. console.log( 'error: ' )
      146. console.log( error.message );
      147. },
      148. /**
      149. * Erfolgreicher allgemeiner Callback
      150. *
      151. * @method on_succes
      152. */
      153. on_succes: function()
      154. {
      155. console.log( 'succes' );
      156. }
      157. }
      Alles anzeigen


      Den kompletten Code diese Tutorials findet man bei Bitbucket.




      Dieses Tutorial findet Ihr auch bei https://app-mit-web.de



      Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von Christian ()

    • So, noch mal sorry, aber war zu viel zu tun Gestern.

      Kurz und knapp (ich bin schon wieder in Action): Du kannst für eine iOS/Android Applikation nur WebSQL Datenbanken verwenden. IndexedDB wird von iOS gar nicht und von Android erst ab Version 4.4 unterstützt, weshalb das gänzlich ausscheidet. WebSQL wird zwar nicht weiter entwickelt, aber von allen Geräten supportet außer von Opera Mini. Eine interessante übersicht dazu findest Du hier: html5rocks.com/de/features/storage

      Wenn Du weitere Fragen hast, melde Dich einfach! :)

      Zum Thema: Bestehende Daten importieren -> Hier erfährst Du, wie Du eine Datenbankverbindung zu MySQL aufbaust: Verbindung mit externer MySQL Datenbank
    • Guten Morgen droidfish,

      um ehrlich zu sein hab ich das bis jetzt noch nicht gebraucht.

      Aus diesem Grund hab ich mal ein bissel gegooglet und bin dabei auf ein paar interessante Punkte gestoßen:

      1.) das Plugin "Cordova-sqlite-storage":
      Zitat aus der Doku:

      Pre-populated database

      For Android, iOS, and Amazon Fire-OS (only): put the database file in the www directory and open the database like:

      var db = window.sqlitePlugin.openDatabase({name: "my.db", createFromLocation: 1});



      2.) Aus der Phonegap Google Gruppe:



      There is a solution for Android, and it is similar to the iphone one. Just include the "Databases.db" and "0000000000000001.db" files in your project's "assets" folder, then at run time copy them over to the below locations.
      String DB_PATH1 = "/data/data/" + this.getClass().getPackage().getName() + "/app_database/Databases.db";
      String DB_PATH2 = "/data/data/" + this.getClass().getPackage().getName() + "/app_database/ file__0/0000000000000001.db";

      Note that the location is actually specified by phonegap. Somewhere in the DroidGap.java source file, you can find the following code:
      // Enable database Package pack = this.getClass().getPackage();
      String appPackage = pack.getName(); WebViewReflect.setStorage(settings, true, "/data/data/" + appPackage + "/app_database/");



      Wobei man hier vorsichtig sein muss weil der Eintrag strammt aus dem Jahre 2011

      3.) Falls die Punkte 1 und 2 nicht gehen gebe es noch die Möglichkeit, dass du dein Projekt nicht mit einer SQLite Db auslieferst sondern mit einem SQL-Dump dieser DB.
      Und wenn deine Anwendung das erste mal gestartet wird parst du den Dump und führst die einzelnen SQL-Statements aus.

      Hoffe einer der Punkt bringt dich weiter :D

      Falls Fragen sind immer her damit!

      Mfg Christian