/**
* Copy data from passed Bundle to current accumulated data. Does some careful processing of the
* data.
*
* @param bookData Source
*/
private void accumulateData(int searchId) {
// See if we got data from this source
if (!mSearchResults.containsKey(searchId)) return;
Bundle bookData = mSearchResults.get(searchId);
// See if we REALLY got data from this source
if (bookData == null) return;
for (String k : bookData.keySet()) {
// If its not there, copy it.
if (!mBookData.containsKey(k)
|| mBookData.getString(k) == null
|| mBookData.getString(k).trim().length() == 0)
mBookData.putString(k, bookData.get(k).toString());
else {
// Copy, append or update data as appropriate.
if (k.equals(CatalogueDBAdapter.KEY_AUTHOR_DETAILS)) {
appendData(k, bookData, mBookData);
} else if (k.equals(CatalogueDBAdapter.KEY_SERIES_DETAILS)) {
appendData(k, bookData, mBookData);
} else if (k.equals(CatalogueDBAdapter.KEY_DATE_PUBLISHED)) {
// Grab a different date if we can parse it.
Date newDate = Utils.parseDate(bookData.getString(k));
if (newDate != null) {
String curr = mBookData.getString(k);
if (Utils.parseDate(curr) == null) {
mBookData.putString(k, Utils.toSqlDateOnly(newDate));
}
}
} else if (k.equals("__thumbnail")) {
appendData(k, bookData, mBookData);
}
}
}
}
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
try {
super.onCreate(savedInstanceState);
mDbHelper = new CatalogueDBAdapter(this);
mDbHelper.open();
setContentView(R.layout.administration_functions);
Bundle extras = getIntent().getExtras();
if (extras != null && extras.containsKey(DOAUTO)) {
try {
if (extras.getString(DOAUTO).equals("export")) {
finish_after = true;
mExportOnStartup = true;
} else {
throw new RuntimeException("Unsupported DOAUTO option");
}
} catch (NullPointerException e) {
Logger.logError(e);
}
}
setupAdmin();
Utils.initBackground(R.drawable.bc_background_gradient_dim, this, false);
} catch (Exception e) {
Logger.logError(e);
}
}
public static void searchGoogle(
String mIsbn, String author, String title, Bundle bookData, boolean fetchThumbnail) {
// replace spaces with %20
author = author.replace(" ", "%20");
title = title.replace(" ", "%20");
String path = "http://books.google.com/books/feeds/volumes";
if (mIsbn.equals("")) {
path += "?q=" + "intitle:" + title + "+inauthor:" + author + "";
} else {
path += "?q=ISBN:" + mIsbn;
}
URL url;
SAXParserFactory factory = SAXParserFactory.newInstance();
SAXParser parser;
SearchGoogleBooksHandler handler = new SearchGoogleBooksHandler();
SearchGoogleBooksEntryHandler entryHandler =
new SearchGoogleBooksEntryHandler(bookData, fetchThumbnail);
try {
url = new URL(path);
parser = factory.newSAXParser();
int count = 0;
// We can't Toast anything from here; it no longer runs in UI thread. So let the caller deal
// with any exceptions.
parser.parse(Utils.getInputStream(url), handler);
count = handler.getCount();
if (count > 0) {
String id = handler.getId();
url = new URL(id);
parser = factory.newSAXParser();
parser.parse(Utils.getInputStream(url), entryHandler);
}
return;
} catch (MalformedURLException e) {
Logger.logError(e);
} catch (ParserConfigurationException e) {
Logger.logError(e);
} catch (SAXException e) {
Logger.logError(e);
} catch (Exception e) {
Logger.logError(e);
}
return;
}
/**
* Handle task search results; start another task if necessary.
*
* @param t
*/
private void handleSearchTaskFinished(SearchThread t) {
SearchThread st = (SearchThread) t;
mCancelledFlg = st.isCancelled();
Bundle bookData = st.getBookData();
mSearchResults.put(st.getSearchId(), bookData);
if (mCancelledFlg) {
mWaitingForIsbn = false;
} else {
if (mSearchingAsin) {
// If we searched AMAZON for an Asin, then see what we found
mSearchingAsin = false;
// Clear the 'isbn'
mIsbn = "";
if (Utils.isNonBlankString(bookData, CatalogueDBAdapter.KEY_ISBN)) {
// We got an ISBN, so pretend we were searching for an ISBN
mWaitingForIsbn = true;
} else {
// See if we got author/title
mAuthor = bookData.getString(CatalogueDBAdapter.KEY_AUTHOR_NAME);
mTitle = bookData.getString(CatalogueDBAdapter.KEY_TITLE);
if (mAuthor != null && !mAuthor.equals("") && mTitle != null && !mTitle.equals("")) {
// We got them, so pretend we are searching by author/title now, and waiting for an
// ASIN...
mWaitingForIsbn = true;
}
}
}
if (mWaitingForIsbn) {
if (Utils.isNonBlankString(bookData, CatalogueDBAdapter.KEY_ISBN)) {
mWaitingForIsbn = false;
// Start the other two...even if they have run before
mIsbn = bookData.getString(CatalogueDBAdapter.KEY_ISBN);
startSearches(mSearchFlags);
} else {
// Start next one that has not run.
startNext();
}
}
}
}
/** Combine all the data and create a book or display an error. */
private void sendResults() {
// This list will be the actual order of the result we apply, based on the
// actual results and the default order.
ArrayList<Integer> results = new ArrayList<Integer>();
if (mHasIsbn) {
// If ISBN was passed, ignore entries with the wrong ISBN, and put entries with no ISBN at the
// end
ArrayList<Integer> uncertain = new ArrayList<Integer>();
for (int i : mDefaultReliabilityOrder) {
if (mSearchResults.containsKey(i)) {
Bundle bookData = mSearchResults.get(i);
if (bookData.containsKey(CatalogueDBAdapter.KEY_ISBN)) {
String isbn = bookData.getString(CatalogueDBAdapter.KEY_ISBN);
if (IsbnUtils.matches(mIsbn, isbn)) {
results.add(i);
}
} else {
uncertain.add(i);
}
}
}
for (Integer i : uncertain) {
results.add(i);
}
// Add the passed ISBN first; avoid overwriting
mBookData.putString(CatalogueDBAdapter.KEY_ISBN, mIsbn);
} else {
// If ISBN was not passed, then just used the default order
for (int i : mDefaultReliabilityOrder) results.add(i);
}
// Merge the data we have. We do this in a fixed order rather than as the threads finish.
for (int i : results) accumulateData(i);
// If there are thumbnails present, pick the biggest, delete others and rename.
Utils.cleanupThumbnails(mBookData);
// Try to use/construct authors
String authors = null;
try {
authors = mBookData.getString(CatalogueDBAdapter.KEY_AUTHOR_DETAILS);
} catch (Exception e) {
}
if (authors == null || authors.equals("")) {
authors = mAuthor;
}
if (authors != null && !authors.equals("")) {
// Decode the collected author names and convert to an ArrayList
ArrayList<Author> aa = Utils.getAuthorUtils().decodeList(authors, '|', false);
mBookData.putSerializable(CatalogueDBAdapter.KEY_AUTHOR_ARRAY, aa);
}
// Try to use/construct title
String title = null;
try {
title = mBookData.getString(CatalogueDBAdapter.KEY_TITLE);
} catch (Exception e) {
}
if (title == null || title.equals("")) title = mTitle;
if (title != null && !title.equals("")) {
mBookData.putString(CatalogueDBAdapter.KEY_TITLE, title);
}
// Try to use/construct isbn
String isbn = null;
try {
isbn = mBookData.getString(CatalogueDBAdapter.KEY_ISBN);
} catch (Exception e) {
}
if (isbn == null || isbn.equals("")) isbn = mIsbn;
if (isbn != null && !isbn.equals("")) {
mBookData.putString(CatalogueDBAdapter.KEY_ISBN, isbn);
}
// Try to use/construct series
String series = null;
try {
series = mBookData.getString(CatalogueDBAdapter.KEY_SERIES_DETAILS);
} catch (Exception e) {
}
if (series != null && !series.equals("")) {
// Decode the collected series names and convert to an ArrayList
try {
ArrayList<Series> sa = Utils.getSeriesUtils().decodeList(series, '|', false);
mBookData.putSerializable(CatalogueDBAdapter.KEY_SERIES_ARRAY, sa);
} catch (Exception e) {
Logger.logError(e);
}
} else {
// add series to stop crashing
mBookData.putSerializable(CatalogueDBAdapter.KEY_SERIES_ARRAY, new ArrayList<Series>());
}
//
// TODO: this needs to be locale-specific. Currently we probably get good-enough data without
// forcing a cleanup.
//
// Removed 20-Jan-2016 PJW; see Issue 717.
//
// Cleanup other fields
// Utils.doProperCase(mBookData, CatalogueDBAdapter.KEY_TITLE);
// Utils.doProperCase(mBookData, CatalogueDBAdapter.KEY_PUBLISHER);
// Utils.doProperCase(mBookData, CatalogueDBAdapter.KEY_DATE_PUBLISHED);
// Utils.doProperCase(mBookData, CatalogueDBAdapter.KEY_SERIES_NAME);
// If book is not found or missing required data, warn the user
if (authors == null || authors.length() == 0 || title == null || title.length() == 0) {
mTaskManager.doToast(BookCatalogueApp.getResourceString(R.string.book_not_found));
}
// Pass the data back
sendSearchFinished();
}
/** Fix background */
@Override
public void onResume() {
super.onResume();
Utils.initBackground(R.drawable.bc_background_gradient_dim, this, false);
if (mExportOnStartup) exportData();
}