();
105 | prettyNameMapping.put("income_date", "Date");
106 | sqliteToExcel.setPrettyNameMapping(prettyNameMapping);
107 | ...
108 | sqliteToExcel.export...
109 | ```
110 | ##### This code snippet shows how to format the value for a column on export (if you want to convert ID's or whatnot to be better displayed)
111 | ```java
112 | sqliteToExcel.setCustomFormatter(new SQLiteToExcel.ExportCustomFormatter() {
113 | @Override
114 | public String process(String columnName, String value) {
115 | switch(columnName) {
116 | case "income_type_id":
117 | int v = Integer.parseInt(value);
118 | switch(v) {
119 | case 10:
120 | value = "Sale";
121 | break;
122 | ...
123 | default:
124 | value = "Unknown";
125 | break;
126 | }
127 | break;
128 | }
129 | return value;
130 | }
131 | });
132 | ```
133 | ## Import Excel into Database
134 | The following snippet is used to initialize the library for Importing Excel
135 | ```java
136 | ExcelToSQLite excelToSQLite = new ExcelToSQLite(getApplicationContext(), "helloworld.db");
137 | ```
138 | or
139 | To drop table while importing the Excel, use the following
140 | ```java
141 | ExcelToSQLite excelToSQLite = new ExcelToSQLite(getApplicationContext(), "helloworld.db", true);
142 | ```
143 |
144 | ##### The following code is used to Import Excel from Assets
145 | ```java
146 | excelToSQLite.importFromAsset("assetFileName.xls", new ExcelToSQLite.ImportListener() {
147 | @Override
148 | public void onStart() {
149 |
150 | }
151 |
152 | @Override
153 | public void onCompleted(String dbName) {
154 |
155 | }
156 |
157 | @Override
158 | public void onError(Exception e) {
159 |
160 | }
161 | });
162 | ```
163 | ##### The following code is used to Import Excel from user directory
164 | ```java
165 | excelToSQLite.importFromFile(directory_path, new ExcelToSQLite.ImportListener() {
166 | @Override
167 | public void onStart() {
168 |
169 | }
170 |
171 | @Override
172 | public void onCompleted(String dbName) {
173 |
174 | }
175 |
176 | @Override
177 | public void onError(Exception e) {
178 |
179 | }
180 | });
181 | ```
182 | ## Proguard for SQLite2XL
183 | ```
184 | -dontwarn org.apache.poi.**
185 | ```
186 |
187 | ## Using SQLite2XL
188 | [Mail](mailto:mushtaqat3gb@gmail.com) me with your Google Play URL and I'll add your app to the list :)
189 |
190 | Icon | Developed By | App
191 | ------------ | ------------- | -------------
192 | 
| AJTechsoft | [Invoicer](https://play.google.com/store/apps/details?id=com.ajts.invoicer&hl=en)
193 | 
| CubanApps | [Facturas Rápidas](https://play.google.com/store/apps/details?id=andsoft.com.facturas&hl=en)
194 |
195 | Wiki
196 | ---------------------
197 | Please visit the [wiki](https://github.com/androidmads/SQLite2XL/wiki) for a complete guide on SQLite2XL.
198 |
199 | ## Quick Solution
200 | * If you find that the exported excel is not opened, read the following issue
201 | https://github.com/androidmads/SQLite2XL/issues/7
202 | * Unable to generate signed APK when proguard is enabled, read the following issue
203 | https://github.com/androidmads/SQLite2XL/issues/8
204 | ## License
205 |
206 | MIT License
207 |
208 | Copyright (c) 2017 AndroidMad / Mushtaq M A
209 |
210 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
documentation files (the "Software"), to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
211 |
212 | The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
213 |
214 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
215 |
216 |
--------------------------------------------------------------------------------
/library/src/main/java/com/ajts/androidmads/library/SQLiteToExcel.java:
--------------------------------------------------------------------------------
1 | package com.ajts.androidmads.library;
2 |
3 | import android.content.Context;
4 | import android.database.Cursor;
5 | import android.database.sqlite.SQLiteDatabase;
6 | import android.os.Environment;
7 | import android.os.Handler;
8 | import android.os.Looper;
9 |
10 | import org.apache.poi.hssf.usermodel.HSSFCell;
11 | import org.apache.poi.hssf.usermodel.HSSFClientAnchor;
12 | import org.apache.poi.hssf.usermodel.HSSFPatriarch;
13 | import org.apache.poi.hssf.usermodel.HSSFRichTextString;
14 | import org.apache.poi.hssf.usermodel.HSSFRow;
15 | import org.apache.poi.hssf.usermodel.HSSFSheet;
16 | import org.apache.poi.hssf.usermodel.HSSFWorkbook;
17 | import org.apache.poi.ss.usermodel.ClientAnchor;
18 |
19 | import java.io.File;
20 | import java.io.FileOutputStream;
21 | import java.util.ArrayList;
22 | import java.util.HashMap;
23 | import java.util.List;
24 |
25 | public class SQLiteToExcel {
26 |
27 | private static Handler handler = new Handler(Looper.getMainLooper());
28 |
29 | private SQLiteDatabase database;
30 | private String mExportPath;
31 | private HSSFWorkbook workbook;
32 |
33 | private List mExcludeColumns = null;
34 | private HashMap mPrettyNameMapping = null;
35 | private ExportCustomFormatter mCustomFormatter = null;
36 |
37 | public SQLiteToExcel(Context context, String dbName) {
38 | this(context, dbName, Environment.getExternalStorageDirectory().toString() + File.separator);
39 | }
40 |
41 | public SQLiteToExcel(Context context, String dbName, String exportPath) {
42 | mExportPath = exportPath;
43 | try {
44 | database = SQLiteDatabase.openOrCreateDatabase(context.getDatabasePath(dbName).getAbsolutePath(), null);
45 | } catch (Exception e) {
46 | e.printStackTrace();
47 | }
48 | }
49 |
50 | /**
51 | * Set the exclude columns list
52 | *
53 | * @param excludeColumns
54 | */
55 | public void setExcludeColumns(List excludeColumns) {
56 | mExcludeColumns = excludeColumns;
57 | }
58 |
59 | /**
60 | * Set the pretty name mapping
61 | *
62 | * @param prettyNameMapping
63 | */
64 | public void setPrettyNameMapping(HashMap prettyNameMapping) {
65 | mPrettyNameMapping = prettyNameMapping;
66 | }
67 |
68 | /**
69 | * Set a the custom formatter for the column value output
70 | * @param customFormatter
71 | */
72 | public void setCustomFormatter(ExportCustomFormatter customFormatter) {
73 | mCustomFormatter = customFormatter;
74 | }
75 |
76 | private ArrayList getAllTables() {
77 | ArrayList tables = new ArrayList<>();
78 | Cursor cursor = database.rawQuery("select name from sqlite_master where type='table' order by name", null);
79 | while (cursor.moveToNext()) {
80 | tables.add(cursor.getString(0));
81 | }
82 | cursor.close();
83 | return tables;
84 | }
85 |
86 | private ArrayList getColumns(String table) {
87 | ArrayList columns = new ArrayList<>();
88 | Cursor cursor = database.rawQuery("PRAGMA table_info(" + table + ")", null);
89 | while (cursor.moveToNext()) {
90 | columns.add(cursor.getString(1));
91 | }
92 | cursor.close();
93 | return columns;
94 | }
95 |
96 | private void exportTables(List tables, final String fileName) throws Exception {
97 | workbook = new HSSFWorkbook();
98 | for (int i = 0; i < tables.size(); i++) {
99 | if (!tables.get(i).equals("android_metadata")) {
100 | HSSFSheet sheet = workbook.createSheet(prettyNameMapping(tables.get(i)));
101 | createSheet(tables.get(i), sheet);
102 | }
103 | }
104 | File file = new File(mExportPath, fileName);
105 | FileOutputStream fos = new FileOutputStream(file);
106 | workbook.write(fos);
107 | fos.flush();
108 | fos.close();
109 | workbook.close();
110 | database.close();
111 | }
112 |
113 | public void exportSingleTable(final String table, final String fileName, ExportListener listener) {
114 | List tables = new ArrayList<>();
115 | tables.add(table);
116 | startExportTables(tables, fileName, listener);
117 | }
118 |
119 | public void exportSpecificTables(final List tables, String fileName, ExportListener listener) {
120 | startExportTables(tables, fileName, listener);
121 | }
122 |
123 | public void exportAllTables(final String fileName, ExportListener listener) {
124 | ArrayList tables = getAllTables();
125 | startExportTables(tables, fileName, listener);
126 | }
127 |
128 | private void startExportTables(final List tables, final String fileName, final ExportListener listener) {
129 | if (listener != null) {
130 | listener.onStart();
131 | }
132 | new Thread(new Runnable() {
133 |
134 | @Override
135 | public void run() {
136 | try {
137 | exportTables(tables, fileName);
138 | if (listener != null) {
139 | handler.post(new Runnable() {
140 | @Override
141 | public void run() {
142 | listener.onCompleted(mExportPath + fileName);
143 | }
144 | });
145 | }
146 | } catch (final Exception e) {
147 | if (database != null && database.isOpen()) {
148 | database.close();
149 | }
150 | if (listener != null)
151 | handler.post(new Runnable() {
152 | @Override
153 | public void run() {
154 | listener.onError(e);
155 | }
156 | });
157 | }
158 | }
159 | }).start();
160 | }
161 |
162 | private void createSheet(String table, HSSFSheet sheet) {
163 | HSSFRow rowA = sheet.createRow(0);
164 | ArrayList columns = getColumns(table);
165 | int cellIndex = 0;
166 | for (int i = 0; i < columns.size(); i++) {
167 | String columnName = prettyNameMapping("" + columns.get(i));
168 | if (!excludeColumn(columnName)) {
169 | HSSFCell cellA = rowA.createCell(cellIndex);
170 | cellA.setCellValue(new HSSFRichTextString(columnName));
171 | cellIndex++;
172 | }
173 | }
174 | insertItemToSheet(table, sheet, columns);
175 | }
176 |
177 | private void insertItemToSheet(String table, HSSFSheet sheet, ArrayList columns) {
178 | HSSFPatriarch patriarch = sheet.createDrawingPatriarch();
179 | Cursor cursor = database.rawQuery("select * from " + table, null);
180 | cursor.moveToFirst();
181 | int n = 1;
182 | while (!cursor.isAfterLast()) {
183 | HSSFRow rowA = sheet.createRow(n);
184 | int cellIndex = 0;
185 | for (int j = 0; j < columns.size(); j++) {
186 | String columnName = "" + columns.get(j);
187 | if (!excludeColumn(columnName)) {
188 | HSSFCell cellA = rowA.createCell(cellIndex);
189 | if (cursor.getType(j) == Cursor.FIELD_TYPE_BLOB) {
190 | HSSFClientAnchor anchor = new HSSFClientAnchor(0, 0, 0, 0, (short) cellIndex, n, (short) (cellIndex + 1), n + 1);
191 | anchor.setAnchorType(ClientAnchor.AnchorType.DONT_MOVE_AND_RESIZE);
192 | patriarch.createPicture(anchor, workbook.addPicture(cursor.getBlob(j), HSSFWorkbook.PICTURE_TYPE_JPEG));
193 | } else {
194 | String value = cursor.getString(j);
195 | if (null != mCustomFormatter) {
196 | value = mCustomFormatter.process(columnName, value);
197 | }
198 | cellA.setCellValue(new HSSFRichTextString(value));
199 | }
200 | cellIndex++;
201 | }
202 | }
203 | n++;
204 | cursor.moveToNext();
205 | }
206 | cursor.close();
207 | }
208 |
209 | /**
210 | * Do we exclude the specified column from the export
211 | *
212 | * @param column
213 | * @return boolean
214 | */
215 | private boolean excludeColumn(String column) {
216 | boolean exclude = false;
217 | if (null != mExcludeColumns) {
218 | return mExcludeColumns.contains(column);
219 | }
220 |
221 | return exclude;
222 | }
223 |
224 | /**
225 | * Convert the specified name to a `pretty` name if a mapping exists
226 | *
227 | * @param name
228 | * @return
229 | */
230 | private String prettyNameMapping(String name) {
231 | if (null != mPrettyNameMapping) {
232 | if (mPrettyNameMapping.containsKey(name)) {
233 | name = mPrettyNameMapping.get(name);
234 | }
235 | }
236 | return name;
237 | }
238 |
239 | public interface ExportListener {
240 | void onStart();
241 |
242 | void onCompleted(String filePath);
243 |
244 | void onError(Exception e);
245 | }
246 |
247 | /**
248 | * Interface class for the custom formatter
249 | */
250 | public interface ExportCustomFormatter {
251 | String process(String columnName, String value);
252 | }
253 | }
--------------------------------------------------------------------------------
7 | ## Sample App
8 | The sample app in the repository is available on Google Play:
9 |
10 | 
11 |
12 | ## Features
13 | ### 1.0.3
14 | Added Pull Request from https://github.com/cleathley
15 | 1. Added the ability to provide a custom formatter to the export.
16 | 2. Added the ability to exclude columns from the export.
17 | 3. Added `pretty` name mapping to export
18 | ### 1.0.2
19 | 1. Added support to add new column from excel while importing, if the column is not exists.
20 | ### 1.0.1
21 | 1. Added Functionality to Import Excel into SQLite Database.
22 | 2. Added Functionality to Export Blob into Image.
23 | 3. Added Functionality to Export List of tables specified.
24 | ## How to Download
25 | add the following library in your app level gradle file
26 | ```groovy
27 | implementation 'com.ajts.androidmads.SQLite2Excel:library:1.0.4'
28 | ```
29 | ## How to Use
30 | #### The steps to use this Library
31 | ```xml
32 |