Native interface to sqlite in a Cordova/PhoneGap plugin for Android, iOS, and Windows "Universal" (8.1) with API similar to HTML5/Web SQL API.
This version is available under GPL v3 (http://www.gnu.org/licenses/gpl.txt) or commercial license. Contact for commercial license: [email protected]
TBD description of this version branch
NOTE (TBD): no Circle CI or Travis CI working in this version branch.
- Free support is available in public locations such as litehelpers / Cordova-sqlite-enterprise-free / issues and https://gitter.im/litehelpers/Cordova-sqlite-storage; commercial support is available by contacting: [email protected]
- Patches patches will NOT be accepted on this project due to potential licensing issues.
- Features omitted from this version branch: pre-populated database support, REGEXP extension for iOS, WP(7/8) and Amazon Fire-OS support
- Windows "Universal" (8.1) version is in an experimental/pre-alpha state:
- Database close and delete operations not yet implemented
- No background processing (for future consideration)
- You may encounter issues with Cordova CLI due to CB-8866; as a workaround you can install using litehelpers / cordova-windows-nufix and
plugmanas described below. - In addition, problems with the Windows "Universal" version have been reported in case of a Cordova project using a Visual Studio template/extension instead of Cordova/PhoneGap CLI or
plugman - Not tested with a Windows 10 (or Windows Phone 10) target; Windows 10 build is not expected to work with Windows Phone
- FTS3, FTS4, and R-Tree support is tested working OK in this version (for target platforms Android/iOS/Windows "Universal")
- Status for the other target platforms:
- Android: now using Android-sqlite-connector (with sqlite
3.7.17), with support for FTS3/FTS4 and R-Tree - iOS: sqlite
3.8.10.2embedded
- Android: now using Android-sqlite-connector (with sqlite
- Android is supported back to SDK 10 (a.k.a. Gingerbread, Android 2.3.3); support for older versions is available upon request.
- FTS3, FTS4, and R-Tree support is tested working OK in this version (for all target platforms Android/iOS/Windows "Universal")
- API to open the database may be changed somewhat to be more streamlined. Transaction and single-statement query API will NOT be changed.
- This version has the following API improvement(s):
- Multi-part transactions API (described below)
- Error result with proper Web SQL
codemember andsqliteCodeas reported by the SQLite C library (Android/iOS)
- This version has the following memory improvements:
- flat JSON interface between Javascript and native parts
- optional: transaction sql chunking, which can be enabled by changing the
MAX_SQL_CHUNKvalue in SQLitePlugin.js
- Android version is now using the lightweight Android-sqlite-connector
- Windows "Universal" version now supports both Windows 8.1 and Windows Phone 8.1
- iOS version is now fixed to override the correct pluginInitialize method and should work with recent versions of iOS
- Project has been renamed to prevent confusion with davibe / Phonegap-SQLitePlugin (original version for iOS, with a different API)
- New project location (should redirect)
- The test suite is completely ported to Jasmine (2.2.0) and was used to verify the functionality of the new Windows version
- SQLCipher for Windows (8.1) in addition to Android & iOS is now supported by litehelpers / Cordova-sqlcipher-adapter
- New
openDatabaseanddeleteDatabaselocationoption to select database location (iOS only) and disable iCloud backup - Fixes to work with PouchDB by @nolanlawson
- Drop-in replacement for HTML5 SQL API, the only change should be
window.openDatabase()-->sqlitePlugin.openDatabase() - Failure-safe nested transactions with batch processing optimizations
- As described in this posting:
- Keeps sqlite database in a user data location that is known; can be reconfigured (iOS version); and synchronized to iCloud by default (iOS version; can be disabled as described below).
- No 5MB maximum, more information at: http://www.sqlite.org/limits.html
- REDCap Mobile App (part of Project REDCap Software for data collection)
- Multi-page apps are not supported and may be broken on Android
- Using web workers is currently not supported and known to be broken on Android
- On Windows "Universal" (8.1), rowsAffected can be wrong when there are multiple levels of nesting of INSERT statements.
- A stability issue was reported on the iOS version when in use together with SockJS client such as pusher-js at the same time. The workaround is to call sqlite functions and SockJS client functions in separate ticks (using setTimeout with 0 timeout).
- If a sql statement fails for which there is no error handler or the error handler does not return
falseto signal transaction recovery, the plugin fires the remaining sql callbacks before aborting the transaction.
- The db version, display name, and size parameter values are not supported and will be ignored.
- This plugin will not work before the callback for the "deviceready" event has been fired, as described in Usage. (This is consistent with the other Cordova plugins.)
- The Android versions cannot work with more than 100 open db files (due to the threading model used).
- UNICODE line separator (
\u2028) is currently not supported and known to be broken in iOS version. - Blob type is currently not supported and known to be broken on multiple platforms.
- UNICODE
\u0000(same as\0) character not working in Android or Windows/Windows Phone (8.1) - Case-insensitive matching and other string manipulations on Unicode characters, which is provided by optional ICU integration in the sqlite source and working with recent versions of Android, is not supported for any target platforms.
- iOS version uses a thread pool but with only one thread working at a time due to "synchronized" database access
- Large query result can be slow, also due to JSON implementation
- ATTACH another database file is not supported (due to path specifications, which work differently depending on the target platform)
- User-defined savepoints are not supported and not expected to be compatible with the transaction locking mechanism used by this plugin. In addition, the use of BEGIN/COMMIT/ROLLBACK statements is not supported.
- UNICODE paragraph separator (
\u2029) - Triggers have only been tested on iOS
- UNICODE characters not fully tested in the Windows "Universal" (8.1) version
- JOIN needs to be tested more.
- litehelpers / Cordova-sqlite-storage - Cordova sqlite storage plugin with permissive licensing terms, supported for more platforms.
- litehelpers / Cordova-sqlcipher-adapter - supports SQLCipher for Android, iOS, and Windows (8.1)
- Original version for iOS (with a different API): davibe / Phonegap-SQLitePlugin
- an-rahulpandey / cordova-plugin-dbcopy - Supports pre-populated database
- EionRobb / phonegap-win8-sqlite - WebSQL add-on for Win8/Metro apps (perhaps with a different API), using an old version of the C++ library from SQLite3-WinRT Component (as referenced by 01org / cordova-win8)
- SQLite3-WinRT Component - C++ component that provides a nice SQLite API with promises for WinJS
- 01org / cordova-win8 - old, unofficial version of Cordova API support for Windows 8 Metro that includes an old version of the C++ SQLite3-WinRT Component
- MSOpenTech / cordova-plugin-websql - Windows 8(+) and Windows Phone 8(+) WebSQL plugin versions in C#
- MetaMemoryT / websql-client - provides the same API and connects to websql-server through WebSockets.
The idea is to emulate the HTML5/Web SQL API as closely as possible. The only major change is to use window.sqlitePlugin.openDatabase() (or sqlitePlugin.openDatabase()) instead of window.openDatabase(). If you see any other major change please report it, it is probably a bug.
NOTE: If a sqlite statement in a transaction fails with an error, the error handler must return false in order to recover the transaction. This is correct according to the HTML5/Web SQL API standard. This is different from the WebKit implementation of Web SQL in Android and iOS which recovers the transaction if a sql error hander returns a non-true value.
There are two options to open a database:
- Recommended:
var db = window.sqlitePlugin.openDatabase({name: "my.db", location: 1}); - Classical:
var db = window.sqlitePlugin.openDatabase("myDatabase.db", "1.0", "Demo", -1);
The new location option is used to select the database subdirectory location (iOS only) with the following choices:
0(default):Documents- visible to iTunes and backed up by iCloud1:Library- backed up by iCloud, NOT visible to iTunes2:Library/LocalDatabase- NOT visible to iTunes and NOT backed up by iCloud
IMPORTANT: Please wait for the "deviceready" event, as in the following example:
// Wait for Cordova to load
document.addEventListener("deviceready", onDeviceReady, false);
// Cordova is ready
function onDeviceReady() {
var db = window.sqlitePlugin.openDatabase({name: "my.db"});
// ...
}NOTE: The database file name should include the extension, if desired.
The following types of SQL transactions are supported by this version:
- Single-statement transactions
- Standard asynchronous transactions
- Multi-part transactions
Sample:
db.executeSql("select length('tenletters') as stringlength", [], function (res) {
var stringlength = res.rows.item(0).stringlength;
console.log('got stringlength: ' + stringlength);
});Sample:
var tx = db.beginTransaction();
tx.executeSql("DROP TABLE IF EXISTS mytable");
tx.executeSql("CREATE TABLE mytable (myfield)");
tx.executeSql("INSERT INTO mytable values(?)", ['test value']);
tx.executeSql("SELECT * from mytable", [], function(tx, res) {
console.log("Got value: " + res.rows.item(0).myfield);
}, function(e) {
console.log("Ignore unexpected error callback with message: " + e.message);
return false;
});
tx.end(function() {
console.log('Optional success callback');
}, function(e) {
console.log("Optional error callback with message: " + e.message);
});Sample with abort:
var tx = db.beginTransaction();
tx.executeSql("INSERT INTO mytable values(?)", ['wrong data']);
tx.abort(function() {
console.log('Optional callback');
});IMPORTANT NOTES:
- In case a
tx.executeSqlcall results in an error and it does not have an error callback or the error callback does NOT returnfalse, the transaction will be aborted with a ROLLBACK upon thetx.endcall. - When a multi-part transaction is started by the
db.beginTransactioncall, all other transactions are blocked until the multi-part transaction is either completed successfully or aborted (with a ROLLBACK).
The threading model depends on which version is used:
- For Android, one background thread per db;
- for iOS, background processing using a very limited thread pool (only one thread working at a time);
- for Windows "Universal" (8.1), no background processing (for future consideration).
This is a pretty strong test: first we create a table and add a single entry, then query the count to check if the item was inserted as expected. Note that a new transaction is created in the middle of the first callback.
// Wait for Cordova to load
document.addEventListener("deviceready", onDeviceReady, false);
// Cordova is ready
function onDeviceReady() {
var db = window.sqlitePlugin.openDatabase({name: "my.db"});
db.transaction(function(tx) {
tx.executeSql('DROP TABLE IF EXISTS test_table');
tx.executeSql('CREATE TABLE IF NOT EXISTS test_table (id integer primary key, data text, data_num integer)');
// demonstrate PRAGMA:
db.executeSql("pragma table_info (test_table);", [], function(res) {
console.log("PRAGMA res: " + JSON.stringify(res));
});
tx.executeSql("INSERT INTO test_table (data, data_num) VALUES (?,?)", ["test", 100], function(tx, res) {
console.log("insertId: " + res.insertId + " -- probably 1");
console.log("rowsAffected: " + res.rowsAffected + " -- should be 1");
db.transaction(function(tx) {
tx.executeSql("select count(id) as cnt from test_table;", [], function(tx, res) {
console.log("res.rows.length: " + res.rows.length + " -- should be 1");
console.log("res.rows.item(0).cnt: " + res.rows.item(0).cnt + " -- should be 1");
});
});
}, function(e) {
console.log("ERROR: " + e.message);
});
});
}NOTE: PRAGMA statements must be executed in executeSql() on the database object (i.e. db.executeSql()) and NOT within a transaction.
In this case, the same transaction in the first executeSql() callback is being reused to run executeSql() again.
// Wait for Cordova to load
document.addEventListener("deviceready", onDeviceReady, false);
// Cordova is ready
function onDeviceReady() {
var db = window.sqlitePlugin.openDatabase("Database", "1.0", "Demo", -1);
db.transaction(function(tx) {
tx.executeSql('DROP TABLE IF EXISTS test_table');
tx.executeSql('CREATE TABLE IF NOT EXISTS test_table (id integer primary key, data text, data_num integer)');
tx.executeSql("INSERT INTO test_table (data, data_num) VALUES (?,?)", ["test", 100], function(tx, res) {
console.log("insertId: " + res.insertId + " -- probably 1");
console.log("rowsAffected: " + res.rowsAffected + " -- should be 1");
tx.executeSql("select count(id) as cnt from test_table;", [], function(tx, res) {
console.log("res.rows.length: " + res.rows.length + " -- should be 1");
console.log("res.rows.item(0).cnt: " + res.rows.item(0).cnt + " -- should be 1");
});
}, function(e) {
console.log("ERROR: " + e.message);
});
});
}This case will also works with Safari (WebKit), assuming you replace window.sqlitePlugin.openDatabase with window.openDatabase.
window.sqlitePlugin.deleteDatabase({name: "my.db", location: 1}, successcb, errorcb);location as described above for openDatabase (iOS only)
NOTE: not implemented for Windows "Universal" (8.1) version.
PREREQUISITE in this version branch ONLY: install recent version of sqlite3.[hc] in src/external and make sure the following constants are defined: #define SQLITE_TEMP_STORE 2 #define SQLITE_THREADSAFE 2 and for Windows Phone 8.1 only: #define SQLITE_WIN32_FILEMAPPING_API 1
IMPORTANT: There are issues supporing certain Windows target platforms due to CB-8866:
- When using Visual Studio, the default target ("Mixed Platforms") will not work
- Problems have been with the Windows "Universal" version case of a Cordova project using a Visual Studio template/extension instead of Cordova/PhoneGap CLI or
plugmanAs an alternative, which will support the ("Mixed Platforms") target, you can useplugmaninstead with litehelpers / cordova-windows-nufix, as described here.
- make sure you have the latest version of
plugmaninstalled:npm install -g plugman - Download the cordova-windows-nufix 3.9.0-nufixpre-01 zipball (or you can clone litehelpers / cordova-windows-nufix instead)
- Create your Windows "Universal" (8.1) project using litehelpers / cordova-windows-nufix:
path.to.cordova-windows-nufix/bin/create.bat your_app_path your.app.id YourAppName
cd your_app_pathand install plugin usingplugman:plugman install --platform windows --project . --plugin https://github.com/litehelpers/Cordova-sqlite-enterprise-free
- Put your sql program in your project
www(don't forget to reference it fromwww\index.htmland wait fordevicereadyevent)
Then your project in CordovaApp.sln should work with "Mixed Platforms" on both Windows 8.1 and Windows Phone 8.1.
npm install -g cordova # if you don't have cordova
cordova create MyProjectFolder com.my.project MyProject && cd MyProjectFolder # if you are just starting
cordova plugin add https://github.com/litehelpers/Cordova-sqlite-enterprise-free
You can find more details at this writeup.
WARNING: for Windows target platform please read the section below.
IMPORTANT: sometimes you have to update the version for a platform before you can build, like: cordova prepare ios
NOTE: If you cannot build for a platform after cordova prepare, you may have to remove the platform and add it again, such as:
cordova platform rm ios
cordova platform add ios
plugman install --platform MYPLATFORM --project path.to.my.project.folder --plugin https://github.com/litehelpers/Cordova-sqlite-enterprise-freewhere MYPLATFORM is android, ios, or windows.
A posting how to get started developing on Windows host without the Cordova CLI tool (for Android target only) is available here.
SQLitePlugin.coffee.md: platform-independent (Literate coffee-script, can be read by recent coffee-script compiler)www:SQLitePlugin.jsplatform-independent Javascript as generated fromSQLitePlugin.coffee.md(and checked in!)src: platform-specific source code:external- placeholder used to importsqlite-connector.jar,sqlite-native-driver.jar(needed for Android version), andsqlite3.[hc](needed to build Windows "Universal" (8.1) version) in this version branchandroid- Java plugin code for Androidios- Objective-C plugin code for iOS;windows- Javascript proxy code and SQLite3-WinRT project for Windows "Universal" (8.1);
spec: test suite using Jasmine (2.2.0), ported from QUnittest-wwwtest suite, working on all platformstests: very simple Jasmine test suite that is run on Circle CI (Android version) and Travis CI (iOS version)Lawnchair-adapter: Lawnchair adaptor, based on the version from the Lawnchair repository, with the basic Lawnchair test suite intest-wwwsubdirectory
These installation instructions are based on the Android example project from Cordova/PhoneGap 2.7.0, using the lib/android/example subdirectory from the PhoneGap 2.7 zipball.
- Install
SQLitePlugin.jsfromwwwintoassets/www - Install
SQLitePlugin.javafromsrc/android/io/liteglueintosrc/io/litegluesubdirectory - Install the
libssubtree fromcommonwithsqlite-connector.jarandsqlite-native-driver.jarinto your Android project - Add the plugin element
<plugin name="SQLitePlugin" value="io.liteglue.SQLitePlugin"/>tores/xml/config.xml
Sample change to res/xml/config.xml for Cordova/PhoneGap 2.x:
--- config.xml.orig 2015-04-14 14:03:05.000000000 +0200
+++ res/xml/config.xml 2015-04-14 14:08:08.000000000 +0200
@@ -36,6 +36,7 @@
<preference name="useBrowserHistory" value="true" />
<preference name="exit-on-suspend" value="false" />
<plugins>
+ <plugin name="SQLitePlugin" value="io.liteglue.SQLitePlugin"/>
<plugin name="App" value="org.apache.cordova.App"/>
<plugin name="Geolocation" value="org.apache.cordova.GeoBroker"/>
<plugin name="Device" value="org.apache.cordova.Device"/>Before building for the first time, you have to update the project with the desired version of the Android SDK with a command like:
android update project --path $(pwd) --target android-19
(assuming Android SDK 19, use the correct desired Android SDK number here)
NOTE: using this plugin on Cordova pre-3.0 requires the following changes to SQLitePlugin.java:
diff -u Cordova-sqlite-storage/src/android/io/liteglue/SQLitePlugin.java src/io/liteglue/SQLitePlugin.java
--- Cordova-sqlite-storage/src/android/io/liteglue/SQLitePlugin.java 2015-04-14 14:05:01.000000000 +0200
+++ src/io/liteglue/SQLitePlugin.java 2015-04-14 14:10:44.000000000 +0200
@@ -22,8 +22,8 @@
import java.util.regex.Matcher;
import java.util.regex.Pattern;
-import org.apache.cordova.CallbackContext;
-import org.apache.cordova.CordovaPlugin;
+import org.apache.cordova.api.CallbackContext;
+import org.apache.cordova.api.CordovaPlugin;
import org.json.JSONArray;
import org.json.JSONException;In the Project "Build Phases" tab, select the first "Link Binary with Libraries" dropdown menu and add the library libsqlite3.dylib or libsqlite3.0.dylib.
NOTE: In the "Build Phases" there can be multiple "Link Binary with Libraries" dropdown menus. Please select the first one otherwise it will not work.
- Copy
SQLitePlugin.[hm]fromsrc/iosinto your project Plugins folder and add them in XCode (I always just have "Create references" as the option selected). - Copy
SQLitePlugin.jsfromwwwinto your projectwwwfolder - Enable the SQLitePlugin in
config.xml
Sample change to config.xml for Cordova/PhoneGap 2.x:
--- config.xml.old 2013-05-17 13:18:39.000000000 +0200
+++ config.xml 2013-05-17 13:18:49.000000000 +0200
@@ -39,6 +39,7 @@
<content src="index.html" />
<plugins>
+ <plugin name="SQLitePlugin" value="SQLitePlugin" />
<plugin name="Device" value="CDVDevice" />
<plugin name="Logger" value="CDVLogger" />
<plugin name="Compass" value="CDVLocation" />Described above.
Assuming your app has a recent template as used by the Cordova create script, add the following code to the onDeviceReady function, after app.receivedEvent('deviceready');:
window.sqlitePlugin.openDatabase({ name: 'hello-world.db' }, function (db) {
db.executeSql("select length('tenletters') as stringlength", [], function (res) {
var stringlength = res.rows.item(0).stringlength;
console.log('got stringlength: ' + stringlength);
document.getElementById('deviceready').querySelector('.received').innerHTML = 'stringlength: ' + stringlength;
});
});Make a change like this to index.html (or use the sample code) verify proper installation:
--- index.html.old 2012-08-04 14:40:07.000000000 +0200
+++ assets/www/index.html 2012-08-04 14:36:05.000000000 +0200
@@ -24,7 +24,35 @@
<title>PhoneGap</title>
<link rel="stylesheet" href="master.css" type="text/css" media="screen" title="no title">
<script type="text/javascript" charset="utf-8" src="cordova-2.0.0.js"></script>
- <script type="text/javascript" charset="utf-8" src="main.js"></script>
+ <script type="text/javascript" charset="utf-8" src="SQLitePlugin.js"></script>
+
+
+ <script type="text/javascript" charset="utf-8">
+ document.addEventListener("deviceready", onDeviceReady, false);
+ function onDeviceReady() {
+ var db = window.sqlitePlugin.openDatabase("Database", "1.0", "Demo", -1);
+
+ db.transaction(function(tx) {
+ tx.executeSql('DROP TABLE IF EXISTS test_table');
+ tx.executeSql('CREATE TABLE IF NOT EXISTS test_table (id integer primary key, data text, data_num integer)');
+
+ tx.executeSql("INSERT INTO test_table (data, data_num) VALUES (?,?)", ["test", 100], function(tx, res) {
+ console.log("insertId: " + res.insertId + " -- probably 1"); // check #18/#38 is fixed
+ alert("insertId: " + res.insertId + " -- should be valid");
+
+ db.transaction(function(tx) {
+ tx.executeSql("SELECT data_num from test_table;", [], function(tx, res) {
+ console.log("res.rows.length: " + res.rows.length + " -- should be 1");
+ alert("res.rows.item(0).data_num: " + res.rows.item(0).data_num + " -- should be 100");
+ });
+ });
+
+ }, function(e) {
+ console.log("ERROR: " + e.message);
+ });
+ });
+ }
+ </script>
</head>
<body onload="init();" id="stage" class="theme">- The plugin class name starts with "SQL" in capital letters, but in Javascript the
sqlitePluginobject name starts with "sql" in small letters. - Attempting to open a database before receiving the "deviceready" event callback.
If you have an issue with the plugin please check the following first:
- You are using the latest version of the Plugin Javascript & platform-specific Java or Objective-C source from this repository.
- You have installed the Javascript & platform-specific Java or Objective-C correctly.
- You have included the correct version of the cordova Javascript and SQLitePlugin.js and got the path right.
- You have registered the plugin properly in
config.xml.
If you still cannot get something to work, please create a fresh, clean Cordova project, add this plugin according to the instructions above, and try a simple test program.
If you continue to see the issue in a fresh, clean Cordova project:
- Make the simplest test program you can to demonstrate the issue, including the following characteristics:
- it completely self-contained, i.e. it is using no extra libraries beyond cordova & SQLitePlugin.js;
- if the issue is with adding data to a table, that the test program includes the statements you used to open the database and create the table;
- if the issue is with retrieving data from a table, that the test program includes the statements you used to open the database, create the table, and enter the data you are trying to retrieve.
Then you can raise the new issue.
The following public discussion forums are available:
- litehelpers / Cordova-sqlite-enterprise-free / issues
- https://gitter.im/litehelpers/Cordova-sqlite-storage
You may contact [email protected]
Unit testing is done in spec.
To run the tests from *nix shell, simply do either:
./bin/test.sh ios
or for Android:
./bin/test.sh android
To run then from a windows powershell do either
.\bin\test.ps1 android
or for Windows (8.1):
.\bin\test.ps1 windows
Please look at the Lawnchair-adapter tree that contains a common adapter, which should also work with the Android version, along with a test-www directory.
Include the following Javascript files in your HTML:
cordova.js(don't forget!)lawnchair.js(you provide)SQLitePlugin.js(in case of Cordova pre-3.0)Lawnchair-sqlitePlugin.js(must come afterSQLitePlugin.jsin case of Cordova pre-3.0)
The name option determines the sqlite database filename, with no extension automatically added. Optionally, you can change the db filename using the db option.
In this example, you would be using/creating a database with filename kvstore:
kvstore = new Lawnchair({name: "kvstore"}, function() {
// do stuff
);Using the db option you can specify the filename with the desired extension and be able to create multiple stores in the same database file. (There will be one table per store.)
recipes = new Lawnchair({db: "cookbook", name: "recipes", ...}, myCallback());
ingredients = new Lawnchair({db: "cookbook", name: "ingredients", ...}, myCallback());KNOWN ISSUE: the new db options are not supported by the Lawnchair adapter. The workaround is to first open the database file using sqlitePlugin.openDatabase().
The adapter is now part of PouchDB thanks to @nolanlawson, see PouchDB FAQ.
NOTE: The PouchDB adapter has not been tested with the Android version which is using the new Android-sqlite-connector.
- Testimonials of apps that are using this plugin would be especially helpful.
- Reporting issues at litehelpers / Cordova-sqlite-enterprise-free / issues can help improve the quality of this plugin.
NOTE: As stated above, patches will NOT be accepted on this project due to potential licensing issues. Issues with reproduction scenarios will help maintain and improve the quality of this plugin for future users.
- https://github.com/liteglue/Android-sqlite-connector
- https://github.com/liteglue/Android-sqlite-native-driver
TBD fix for this version:
cordova-sqlite-common/- source for Android (not using Android-sqlite-connector), iOS, Windows (8.1), and Amazon Fire-OS versions (shared with litehelpers / Cordova-sqlcipher-adapter)common-srcevfree-rc- pre-release of free enterprise version for all supported platforms, including library dependencies for Android, Windows (8.1), and WP(7/8)- [FUTURE TBD]
master- version for release, to be included in PhoneGap build.