- status.message.emit(tr("Error sending local note: ") +e);\r
- logger.log(logger.LOW, e.toString()); \r
- error = true;\r
- } catch (TException e) {\r
- logger.log(logger.LOW, "*** EDAM TExcepton syncLocalNotes "+e);\r
- status.message.emit(tr("Error sending local note: ") +e);\r
- logger.log(logger.LOW, e.toString()); \r
- error = true;\r
- }\r
- }\r
- logger.log(logger.HIGH, "Leaving SyncRunner.syncLocalNote");\r
-\r
- }\r
-\r
- // Sync Notebooks with Evernote\r
- private void syncLocalNotebooks(Client noteStore) {\r
- logger.log(logger.HIGH, "Entering SyncRunner.syncLocalNotebooks");\r
- \r
- status.message.emit(tr("Sending local notebooks."));\r
- List<Notebook> remoteList = new ArrayList<Notebook>();\r
- try {\r
- logger.log(logger.EXTREME, "Getting remote notebooks to compare with local");\r
- remoteList = noteStore.listNotebooks(authToken);\r
- } catch (EDAMUserException e1) {\r
- logger.log(logger.LOW, "*** EDAM User Excepton syncLocalNotebooks getting remote Notebook List");\r
- status.message.emit(tr("Error: ") +e1);\r
- logger.log(logger.LOW, e1.toString()); \r
- error = true;\r
- } catch (EDAMSystemException e1) {\r
- logger.log(logger.LOW, "*** EDAM System Excepton syncLocalNotebooks getting remote Notebook List");\r
- status.message.emit(tr("Error: ") +e1);\r
- logger.log(logger.LOW, e1.toString()); \r
- error = true;\r
- } catch (TException e1) {\r
- logger.log(logger.LOW, "*** EDAM Transaction Excepton syncLocalNotebooks getting remote Notebook List");\r
- status.message.emit(tr("Error: ") +e1);\r
- logger.log(logger.LOW, e1.toString()); \r
- error = true;\r
- }\r
- logger.log(logger.EXTREME, "Getting local dirty notebooks");\r
- List<Notebook> notebooks = conn.getNotebookTable().getDirty();\r
- int sequence;\r
- // Sync the local notebooks with Evernote's\r
- for (int i=0; i<notebooks.size() && keepRunning; i++) {\r
- \r
-// if (authRefreshNeeded)\r
-// if (!refreshConnection())\r
-// return;\r
- \r
- Notebook enNotebook = notebooks.get(i);\r
- try {\r
- if (enNotebook.getUpdateSequenceNum() > 0) {\r
- logger.log(logger.EXTREME, "Existing notebook is dirty");\r
- sequence = noteStore.updateNotebook(authToken, enNotebook);\r
- } else {\r
- logger.log(logger.EXTREME, "New dirty notebook found");\r
- String oldGuid = enNotebook.getGuid();\r
- boolean found = false;\r
- \r
- // Look for a notebook with the same name. If one is found, we don't need \r
- // to create another one\r
- logger.log(logger.EXTREME, "Looking for matching notebook name");\r
- for (int k=0; k<remoteList.size() && !found && keepRunning; k++) {\r
- if (remoteList.get(k).getName().equalsIgnoreCase(enNotebook.getName())) {\r
- enNotebook = remoteList.get(k);\r
- logger.log(logger.EXTREME, "Matching notebook found");\r
- found = true;\r
- }\r
- }\r
- if (!found)\r
- enNotebook = noteStore.createNotebook(authToken, enNotebook);\r
- \r
- logger.log(logger.EXTREME, "Updating notebook in database");\r
- conn.getNotebookTable().updateNotebookGuid(oldGuid, enNotebook.getGuid());\r
- sequence = enNotebook.getUpdateSequenceNum();\r
- }\r
- logger.log(logger.EXTREME, "Updating notebook sequence in database");\r
- conn.getNotebookTable().updateNotebookSequence(enNotebook.getGuid(), sequence);\r
- logger.log(logger.EXTREME, "Resetting dirty flag in notebook");\r
- conn.getNotebookTable().resetDirtyFlag(enNotebook.getGuid());\r
- updateSequenceNumber = sequence;\r
- logger.log(logger.EXTREME, "Emitting sequence number to main thread");\r
- conn.getSyncTable().setUpdateSequenceNumber(updateSequenceNumber);\r
- } catch (EDAMUserException e) {\r
- logger.log(logger.LOW, "*** EDAM User Excepton syncLocalNotebooks");\r
- logger.log(logger.LOW, e.toString()); \r
- error = true;\r
- } catch (EDAMSystemException e) {\r
- logger.log(logger.LOW, "*** EDAM System Excepton syncLocalNotebooks");\r
- logger.log(logger.LOW, e.toString()); \r
- error = true;\r
- } catch (EDAMNotFoundException e) {\r
- logger.log(logger.LOW, "*** EDAM Not Found Excepton syncLocalNotebooks");\r
- logger.log(logger.LOW, e.toString()); \r
- error = true;\r
- } catch (TException e) {\r
- logger.log(logger.LOW, "*** EDAM TExcepton syncLocalNotebooks");\r
- logger.log(logger.LOW, e.toString()); \r
- error = true;\r
- } \r
- }\r
- logger.log(logger.HIGH, "Leaving SyncRunner.syncLocalNotebooks");\r
-\r
- }\r
- // Sync Tags with Evernote\r
- private void syncLocalTags(Client noteStore) {\r
- logger.log(logger.HIGH, "Entering SyncRunner.syncLocalTags");\r
- List<Tag> remoteList = new ArrayList<Tag>();\r
- status.message.emit(tr("Sending local tags."));\r
- \r
- try {\r
- logger.log(logger.EXTREME, "Getting remote tags to compare names with the local tags");\r
- remoteList = noteStore.listTags(authToken);\r
- } catch (EDAMUserException e1) {\r
- logger.log(logger.LOW, "*** EDAM User Excepton syncLocalTags getting remote Tag List");\r
- status.message.emit(tr("Error: ") +e1);\r
- logger.log(logger.LOW, e1.toString()); \r
- error = true;\r
- } catch (EDAMSystemException e1) {\r
- logger.log(logger.LOW, "*** EDAM System Excepton syncLocalTags getting remote Tag List");\r
- status.message.emit(tr("Error: ") +e1);\r
- logger.log(logger.LOW, e1.toString()); \r
- error = true;\r
- } catch (TException e1) {\r
- logger.log(logger.LOW, "*** EDAM Transaction Excepton syncLocalTags getting remote Tag List");\r
- status.message.emit(tr("Error: ") +e1);\r
- logger.log(logger.LOW, e1.toString()); \r
- error = true;\r
- } \r
- \r
- int sequence;\r
- \r
- if (badTagSync == null)\r
- badTagSync = new HashMap<String,String>();\r
- else\r
- badTagSync.clear();\r
- \r
- Tag enTag = findNextTag();\r
- \r
- // This is a hack. Sometimes this function goes flookey and goes into a \r
- // perpetual loop. This causes NeverNote to flood Evernote's servers.\r
- // This is a safety valve to prevent unlimited loops.\r
- int maxCount = conn.getTagTable().getDirty().size()+10;\r
- int loopCount = 0;\r
- \r
- while(enTag!=null && loopCount < maxCount) {\r
- loopCount++;\r
-// if (authRefreshNeeded)\r
-// if (!refreshConnection())\r
-// return;\r
-\r
- try {\r
- if (enTag.getUpdateSequenceNum() > 0) {\r
- logger.log(logger.EXTREME, "Updating tag");\r
- sequence = noteStore.updateTag(authToken, enTag);\r
- } else {\r
- \r
- // Look for a tag with the same name. If one is found, we don't need \r
- // to create another one\r
- logger.log(logger.EXTREME, "New tag. Comparing with remote names");\r
- boolean found = false;\r
- String oldGuid = enTag.getGuid();\r
- for (int k=0; k<remoteList.size() && !found && keepRunning; k++) {\r
- if (remoteList.get(k).getName().equalsIgnoreCase(enTag.getName())) {\r
- conn.getTagTable().updateTagGuid(enTag.getGuid(), remoteList.get(k).getGuid());\r
- enTag = remoteList.get(k);\r
- logger.log(logger.EXTREME, "Matching tag name found");\r
- found = true;\r
- }\r
- }\r
- if (!found)\r
- enTag = noteStore.createTag(authToken, enTag);\r
- else\r
- enTag.setUpdateSequenceNum(noteStore.updateTag(authToken,enTag));\r
- sequence = enTag.getUpdateSequenceNum();\r
- if (!oldGuid.equals(enTag.getGuid())) {\r
- logger.log(logger.EXTREME, "Updating tag guid");\r
- conn.getTagTable().updateTagGuid(oldGuid, enTag.getGuid());\r
- }\r
- }\r
- logger.log(logger.EXTREME, "Updating tag sequence number");\r
- conn.getTagTable().updateTagSequence(enTag.getGuid(), sequence);\r
- logger.log(logger.EXTREME, "Resetting tag dirty flag");\r
- conn.getTagTable().resetDirtyFlag(enTag.getGuid());\r
- logger.log(logger.EXTREME, "Emitting sequence number to the main thread.");\r
- updateSequenceNumber = sequence;\r
- conn.getSyncTable().setUpdateSequenceNumber(updateSequenceNumber);\r
- } catch (EDAMUserException e) {\r
- logger.log(logger.LOW, "*** EDAM User Excepton syncLocalTags: " +enTag.getName());\r
- logger.log(logger.LOW, e.toString());\r
- badTagSync.put(enTag.getGuid(),null);\r
- error = true;\r
- } catch (EDAMSystemException e) {\r
- logger.log(logger.LOW, "** EDAM System Excepton syncLocalTags: " +enTag.getName());\r
- logger.log(logger.LOW, e.toString()); \r
- badTagSync.put(enTag.getGuid(),null);\r
- error = true;\r
- } catch (EDAMNotFoundException e) {\r
- logger.log(logger.LOW, "*** EDAM Not Found Excepton syncLocalTags: " +enTag.getName());\r
- logger.log(logger.LOW, e.toString());\r
- badTagSync.put(enTag.getGuid(),null);\r
- error = true;\r
- } catch (TException e) {\r
- logger.log(logger.LOW, "*** EDAM TExcepton syncLocalTags: " +enTag.getName());\r
- logger.log(logger.LOW, e.toString());\r
- badTagSync.put(enTag.getGuid(),null);\r
- error = true;\r
- } \r
- \r
- // Find the next tag\r
- logger.log(logger.EXTREME, "Finding next tag");\r
- enTag = findNextTag();\r
- }\r
- logger.log(logger.HIGH, "Leaving SyncRunner.syncLocalTags");\r
- }\r
- private void syncLocalLinkedNotebooks(Client noteStore) {\r
- logger.log(logger.HIGH, "Entering SyncRunner.syncLocalLinkedNotebooks");\r
- \r
- List<String> list = conn.getLinkedNotebookTable().getDirtyGuids();\r
- for (int i=0; i<list.size(); i++) {\r
- LinkedNotebook book = conn.getLinkedNotebookTable().getNotebook(list.get(i));\r
- try {\r
- noteStore.updateLinkedNotebook(authToken, book);\r
- } catch (EDAMUserException e) {\r
- logger.log(logger.LOW, "*** EDAM User Excepton syncLocalLinkedNotebooks");\r
- status.message.emit(tr("Error: ") +e);\r
- logger.log(logger.LOW, e.toString()); \r
- error = true;\r
- e.printStackTrace();\r
- } catch (EDAMNotFoundException e) {\r
- logger.log(logger.LOW, "*** EDAM Not Found Excepton syncLocalLinkedNotebooks");\r
- status.message.emit(tr("Error: ") +e);\r
- logger.log(logger.LOW, e.toString()); \r
- error = true;\r
- e.printStackTrace();\r
- } catch (EDAMSystemException e) {\r
- logger.log(logger.LOW, "*** EDAM System Excepton syncLocalLinkedNotebooks");\r
- status.message.emit(tr("Error: ") +e);\r
- logger.log(logger.LOW, e.toString()); \r
- error = true;\r
- e.printStackTrace();\r
- } catch (TException e) {\r
- logger.log(logger.LOW, "*** EDAM TExcepton syncLocalLinkedNotebooks");\r
- status.message.emit(tr("Error: ") +e);\r
- logger.log(logger.LOW, e.toString()); \r
- error = true;\r
- e.printStackTrace();\r
- }\r
- }\r
- logger.log(logger.HIGH, "Leaving SyncRunner.syncLocalLinkedNotebooks");\r
- }\r
- // Sync Saved Searches with Evernote\r
- private void syncLocalSavedSearches(Client noteStore) {\r
- logger.log(logger.HIGH, "Entering SyncRunner.syncLocalSavedSearches");\r
- List<SavedSearch> remoteList = new ArrayList<SavedSearch>();\r
- status.message.emit(tr("Sending saved searches."));\r
- \r
- logger.log(logger.EXTREME, "Getting saved searches to compare with local");\r
- try {\r
- remoteList = noteStore.listSearches(authToken);\r
- } catch (EDAMUserException e1) {\r
- logger.log(logger.LOW, "*** EDAM User Excepton syncLocalTags getting remote saved search List");\r
- status.message.emit(tr("Error: ") +e1);\r
- logger.log(logger.LOW, e1.toString()); \r
- error = true;\r
- } catch (EDAMSystemException e1) {\r
- logger.log(logger.LOW, "*** EDAM System Excepton syncLocalTags getting remote saved search List");\r
- status.message.emit(tr("Error: ") +e1);\r
- logger.log(logger.LOW, e1.toString()); \r
- error = true;\r
- } catch (TException e1) {\r
- logger.log(logger.LOW, "*** EDAM Transaction Excepton syncLocalTags getting remote saved search List");\r
- status.message.emit(tr("Error: ") +e1);\r
- logger.log(logger.LOW, e1.toString()); \r
- error = true;\r
- } \r
- \r
- List<SavedSearch> searches = conn.getSavedSearchTable().getDirty();\r
- int sequence;\r
- // Sync the local notebooks with Evernote's\r
- logger.log(logger.EXTREME, "Beginning to send saved searches");\r
- for (int i=0; i<searches.size() && keepRunning; i++) {\r
- \r
-// if (authRefreshNeeded)\r
-// if (!refreshConnection())\r
-// return;\r
- \r
- SavedSearch enSearch = searches.get(i);\r
- try {\r
- if (enSearch.getUpdateSequenceNum() > 0) \r
- sequence = noteStore.updateSearch(authToken, enSearch);\r
- else {\r
- logger.log(logger.EXTREME, "New saved search found.");\r
- // Look for a tag with the same name. If one is found, we don't need \r
- // to create another one\r
- boolean found = false;\r
- logger.log(logger.EXTREME, "Matching remote saved search names with local");\r
- for (int k=0; k<remoteList.size() && !found && keepRunning; k++) {\r
- if (remoteList.get(k).getName().equalsIgnoreCase(enSearch.getName())) {\r
- enSearch = remoteList.get(k);\r
- found = true;\r
- logger.log(logger.EXTREME, "Matching saved search found");\r
- sequence = enSearch.getUpdateSequenceNum();\r
- }\r
- }\r
-\r
- String oldGuid = enSearch.getGuid();\r
- if (!found)\r
- enSearch = noteStore.createSearch(authToken, enSearch);\r
- sequence = enSearch.getUpdateSequenceNum();\r
- logger.log(logger.EXTREME, "Updating tag guid in local database");\r
- conn.getTagTable().updateTagGuid(oldGuid, enSearch.getGuid());\r
- }\r
- logger.log(logger.EXTREME, "Updating tag sequence in local database");\r
- conn.getSavedSearchTable().updateSavedSearchSequence(enSearch.getGuid(), sequence);\r
- logger.log(logger.EXTREME, "Resetting tag dirty flag");\r
- conn.getSavedSearchTable().resetDirtyFlag(enSearch.getGuid());\r
- logger.log(logger.EXTREME, "Emitting sequence number to the main thread.");\r
- updateSequenceNumber = sequence;\r
- conn.getSyncTable().setUpdateSequenceNumber(updateSequenceNumber);\r
- } catch (EDAMUserException e) {\r
- logger.log(logger.LOW, "*** EDAM User Excepton syncLocalTags");\r
- logger.log(logger.LOW, e.toString()); \r
- error = true;\r
- } catch (EDAMSystemException e) {\r
- logger.log(logger.LOW, "** EDAM System Excepton syncLocalTags");\r
- logger.log(logger.LOW, e.toString()); \r
- error = true;\r
- } catch (EDAMNotFoundException e) {\r
- logger.log(logger.LOW, "*** EDAM Not Found Excepton syncLocalTags");\r
- logger.log(logger.LOW, e.toString()); \r
- error = true;\r
- } catch (TException e) {\r
- logger.log(logger.LOW, "*** EDAM TExcepton syncLocalTags");\r
- logger.log(logger.LOW, e.toString()); \r
- error = true;\r
- } \r
- }\r
-\r
- logger.log(logger.HIGH, "Entering SyncRunner.syncLocalSavedSearches");\r
- } \r
-\r
- // Sync evernote changes with local database\r
- private void syncRemoteToLocal(Client noteStore) {\r
- logger.log(logger.HIGH, "Entering SyncRunner.syncRemoteToLocal");\r
-\r
- List<Note> dirtyNotes = conn.getNoteTable().getDirty();\r
- dirtyNoteGuids = new Vector<String>();\r
- for (int i=0; i<dirtyNotes.size() && keepRunning; i++) {\r
- dirtyNoteGuids.add(dirtyNotes.get(i).getGuid());\r
- }\r
- \r
- int chunkSize = 10;\r
- SyncChunk chunk = null;\r
- boolean fullSync = false;\r
- boolean more = true;\r
- \r
- if (updateSequenceNumber == 0)\r
- fullSync = true;\r
- \r
- status.message.emit(tr("Downloading 0% complete."));\r
- \r
- while(more && keepRunning) {\r
- \r
-// if (authRefreshNeeded)\r
-// if (!refreshConnection())\r
-// return;\r
- \r
- int sequence = updateSequenceNumber;\r
- try {\r
-// conn.beginTransaction();\r
- logger.log(logger.EXTREME, "Getting chunk from Evernote");\r
- chunk = noteStore.getSyncChunk(authToken, sequence, chunkSize, fullSync);\r
- } catch (EDAMUserException e) {\r
- error = true;\r
- e.printStackTrace();\r
- status.message.emit(e.getMessage());\r
- } catch (EDAMSystemException e) {\r
- error = true;\r
- e.printStackTrace();\r
- status.message.emit(e.getMessage());\r
- } catch (TException e) {\r
- error = true;\r
- e.printStackTrace();\r
- status.message.emit(e.getMessage());\r
- } \r
- if (error || chunk == null) \r
- return;\r
- \r
- \r
- \r
- syncRemoteTags(chunk.getTags());\r
- syncRemoteSavedSearches(chunk.getSearches());\r
- syncRemoteNotebooks(chunk.getNotebooks());\r
- syncRemoteNotes(noteStore, chunk.getNotes(), fullSync, authToken);\r
- syncRemoteResources(noteStore, chunk.getResources());\r
- syncRemoteLinkedNotebooks(chunk.getLinkedNotebooks());\r
- \r
- // Signal about any updated notes to invalidate the cache\r
- for (int i=0; i<chunk.getNotesSize(); i++) \r
- noteSignal.noteChanged.emit(chunk.getNotes().get(i).getGuid(), null); \r
- syncExpungedNotes(chunk);\r
- \r
- \r
- // Check for more notes\r
- if (chunk.getChunkHighUSN() <= updateSequenceNumber) \r
- more = false;\r
- if (error)\r
- more = false;\r
- logger.log(logger.EXTREME, "More notes? " +more);\r
+ //status.message.emit("Error deleting local note: " +e +" - Continuing");
+ //logger.log(logger.LOW, e.toString());
+ //error = true;
+ } catch (TException e) {
+ logger.log(logger.LOW, "*** EDAM TExcepton syncLocalNotes "+e);
+ status.message.emit(tr("Error sending local note: ") +e);
+ logger.log(logger.LOW, e.toString());
+ error = true;
+ }
+ }
+ }
+ // Sync notes with Evernote
+ private void syncLocalNotes() {
+ logger.log(logger.HIGH, "Entering SyncRunner.syncNotes");
+ logger.log(logger.LOW, "Dirty local notes found: " +new Integer(conn.getNoteTable().getDirtyCount()).toString());
+ status.message.emit(tr("Sending local notes."));
+
+ List<Note> notes = conn.getNoteTable().getDirty();
+ // Sync the local notebooks with Evernote's
+ for (int i=0; i<notes.size() && keepRunning; i++) {
+ syncLocalNote(localNoteStore, notes.get(i), authToken);
+ }
+ logger.log(logger.HIGH, "Leaving SyncRunner.syncNotes");
+
+ }
+ // Sync notes with Evernote
+ private void syncLocalNote(Client noteStore, Note enNote, String token) {
+ logger.log(logger.HIGH, "Entering SyncRunner.syncNotes");
+ status.message.emit(tr("Sending local notes."));
+
+ if (enNote.isActive()) {
+ try {
+ if (enNote.getUpdateSequenceNum() > 0) {
+ logger.log(logger.EXTREME, "Active dirty note found - non new - " +enNote.getGuid());
+ logger.log(logger.EXTREME, "Fetching note content");
+ enNote = getNoteContent(enNote);
+ logger.log(logger.MEDIUM, "Updating note : "+ enNote.getGuid() +" <title>" +enNote.getTitle()+"</title>");
+ enNote = noteStore.updateNote(token, enNote);
+ } else {
+ logger.log(logger.EXTREME, "Active dirty found - new note " +enNote.getGuid());
+ String oldGuid = enNote.getGuid();
+ logger.log(logger.MEDIUM, "Fetching note content");
+ enNote = getNoteContent(enNote);
+ logger.log(logger.MEDIUM, "Creating note : "+ enNote.getGuid() +" <title>" +enNote.getTitle()+"</title>");
+ enNote = noteStore.createNote(token, enNote);
+ logger.log(logger.MEDIUM, "New note Guid : "+ enNote.getGuid() +" <title>" +enNote.getTitle()+"</title>");
+ noteSignal.guidChanged.emit(oldGuid, enNote.getGuid());
+ conn.getNoteTable().updateNoteGuid(oldGuid, enNote.getGuid());
+ }
+ updateSequenceNumber = enNote.getUpdateSequenceNum();
+ logger.log(logger.EXTREME, "Saving note");
+ conn.getNoteTable().updateNoteSequence(enNote.getGuid(), enNote.getUpdateSequenceNum());
+ List<Resource> rl = enNote.getResources();
+ logger.log(logger.EXTREME, "Getting note resources");
+ for (int j=0; j<enNote.getResourcesSize() && keepRunning; j++) {
+ Resource newRes = rl.get(j);
+ Data d = newRes.getData();
+ if (d!=null) {
+ logger.log(logger.EXTREME, "Calculating resource hash");
+ String hash = byteArrayToHexString(d.getBodyHash());
+ logger.log(logger.EXTREME, "updating resources by hash");
+ String oldGuid = conn.getNoteTable().noteResourceTable.getNoteResourceGuidByHashHex(enNote.getGuid(), hash);
+ conn.getNoteTable().updateNoteResourceGuidbyHash(enNote.getGuid(), newRes.getGuid(), hash);
+ resourceSignal.resourceGuidChanged.emit(enNote.getGuid(), oldGuid, newRes.getGuid());
+ }
+ }
+ logger.log(logger.EXTREME, "Resetting note dirty flag");
+ conn.getNoteTable().resetDirtyFlag(enNote.getGuid());
+ updateSequenceNumber = enNote.getUpdateSequenceNum();
+ logger.log(logger.EXTREME, "Emitting note sequence number change");
+ conn.getSyncTable().setUpdateSequenceNumber(updateSequenceNumber);
+
+ } catch (EDAMUserException e) {
+ logger.log(logger.LOW, "*** EDAM User Excepton syncLocalNotes "+e);
+ status.message.emit(tr("Error sending local note: ") +e.getParameter());
+ logger.log(logger.LOW, e.toString());
+ error = true;
+ } catch (EDAMSystemException e) {
+ if (e.getErrorCode() == EDAMErrorCode.RATE_LIMIT_REACHED) {
+ limitSignal.rateLimitReached.emit(e.getRateLimitDuration());
+ }
+ logger.log(logger.LOW, "*** EDAM System Excepton syncLocalNotes "+e);
+ status.message.emit(tr("Error: ") +e);
+ logger.log(logger.LOW, e.toString());
+ error = true;
+ } catch (EDAMNotFoundException e) {
+ logger.log(logger.LOW, "*** EDAM Not Found Excepton syncLocalNotes " +e);
+ status.message.emit(tr("Error sending local note: ") +e);
+ logger.log(logger.LOW, e.toString());
+ error = true;
+ } catch (TException e) {
+ logger.log(logger.LOW, "*** EDAM TExcepton syncLocalNotes "+e);
+ status.message.emit(tr("Error sending local note: ") +e);
+ logger.log(logger.LOW, e.toString());
+ error = true;
+ }
+ }
+ logger.log(logger.HIGH, "Leaving SyncRunner.syncLocalNote");
+
+ }
+
+ // Sync Notebooks with Evernote
+ private void syncLocalNotebooks(Client noteStore) {
+ logger.log(logger.HIGH, "Entering SyncRunner.syncLocalNotebooks");
+
+ status.message.emit(tr("Sending local notebooks."));
+ List<Notebook> remoteList = new ArrayList<Notebook>();
+ try {
+ logger.log(logger.EXTREME, "Getting remote notebooks to compare with local");
+ remoteList = noteStore.listNotebooks(authToken);
+ } catch (EDAMUserException e1) {
+ logger.log(logger.LOW, "*** EDAM User Excepton syncLocalNotebooks getting remote Notebook List");
+ status.message.emit(tr("Error: ") +e1);
+ logger.log(logger.LOW, e1.toString());
+ error = true;
+ } catch (EDAMSystemException e1) {
+ if (e1.getErrorCode() == EDAMErrorCode.RATE_LIMIT_REACHED) {
+ limitSignal.rateLimitReached.emit(e1.getRateLimitDuration());
+ }
+ logger.log(logger.LOW, "*** EDAM System Excepton syncLocalNotebooks getting remote Notebook List");
+ status.message.emit(tr("Error: ") +e1);
+ logger.log(logger.LOW, e1.toString());
+ error = true;
+ } catch (TException e1) {
+ logger.log(logger.LOW, "*** EDAM Transaction Excepton syncLocalNotebooks getting remote Notebook List");
+ status.message.emit(tr("Error: ") +e1);
+ logger.log(logger.LOW, e1.toString());
+ error = true;
+ }
+ logger.log(logger.EXTREME, "Getting local dirty notebooks");
+ List<Notebook> notebooks = conn.getNotebookTable().getDirty();
+ int sequence;
+ // Sync the local notebooks with Evernote's
+ for (int i=0; i<notebooks.size() && keepRunning; i++) {
+
+// if (authRefreshNeeded)
+// if (!refreshConnection())
+// return;
+
+ Notebook enNotebook = notebooks.get(i);
+ try {
+ if (enNotebook.getUpdateSequenceNum() > 0) {
+ logger.log(logger.EXTREME, "Existing notebook is dirty");
+ sequence = noteStore.updateNotebook(authToken, enNotebook);
+ } else {
+ logger.log(logger.EXTREME, "New dirty notebook found");
+ String oldGuid = enNotebook.getGuid();
+ boolean found = false;
+
+ // Look for a notebook with the same name. If one is found, we don't need
+ // to create another one
+ logger.log(logger.EXTREME, "Looking for matching notebook name");
+ for (int k=0; k<remoteList.size() && !found && keepRunning; k++) {
+ if (remoteList.get(k).getName().equalsIgnoreCase(enNotebook.getName())) {
+ enNotebook = remoteList.get(k);
+ logger.log(logger.EXTREME, "Matching notebook found");
+ found = true;
+ }
+ }
+ if (!found)
+ enNotebook = noteStore.createNotebook(authToken, enNotebook);
+
+ logger.log(logger.EXTREME, "Updating notebook in database");
+ conn.getNotebookTable().updateNotebookGuid(oldGuid, enNotebook.getGuid());
+ sequence = enNotebook.getUpdateSequenceNum();
+ }
+ logger.log(logger.EXTREME, "Updating notebook sequence in database");
+ conn.getNotebookTable().updateNotebookSequence(enNotebook.getGuid(), sequence);
+ logger.log(logger.EXTREME, "Resetting dirty flag in notebook");
+ conn.getNotebookTable().resetDirtyFlag(enNotebook.getGuid());
+ updateSequenceNumber = sequence;
+ logger.log(logger.EXTREME, "Emitting sequence number to main thread");
+ conn.getSyncTable().setUpdateSequenceNumber(updateSequenceNumber);
+ } catch (EDAMUserException e) {
+ logger.log(logger.LOW, "*** EDAM User Excepton syncLocalNotebooks");
+ logger.log(logger.LOW, e.toString() + ": Stack : " +enNotebook.getStack());
+ error = true;
+ } catch (EDAMSystemException e) {
+ if (e.getErrorCode() == EDAMErrorCode.RATE_LIMIT_REACHED) {
+ limitSignal.rateLimitReached.emit(e.getRateLimitDuration());
+ }
+ logger.log(logger.LOW, "*** EDAM System Excepton syncLocalNotebooks");
+ logger.log(logger.LOW, e.toString());
+ error = true;
+ } catch (EDAMNotFoundException e) {
+ logger.log(logger.LOW, "*** EDAM Not Found Excepton syncLocalNotebooks");
+ logger.log(logger.LOW, e.toString());
+ error = true;
+ } catch (TException e) {
+ logger.log(logger.LOW, "*** EDAM TExcepton syncLocalNotebooks");
+ logger.log(logger.LOW, e.toString());
+ error = true;
+ }
+ }
+ logger.log(logger.HIGH, "Leaving SyncRunner.syncLocalNotebooks");
+
+ }
+ // Sync Tags with Evernote
+ private void syncLocalTags(Client noteStore) {
+ logger.log(logger.HIGH, "Entering SyncRunner.syncLocalTags");
+ List<Tag> remoteList = new ArrayList<Tag>();
+ status.message.emit(tr("Sending local tags."));
+
+ try {
+ logger.log(logger.EXTREME, "Getting remote tags to compare names with the local tags");
+ remoteList = noteStore.listTags(authToken);
+ } catch (EDAMUserException e1) {
+ logger.log(logger.LOW, "*** EDAM User Excepton syncLocalTags getting remote Tag List");
+ status.message.emit(tr("Error: ") +e1);
+ logger.log(logger.LOW, e1.toString());
+ error = true;
+ } catch (EDAMSystemException e1) {
+ if (e1.getErrorCode() == EDAMErrorCode.RATE_LIMIT_REACHED) {
+ limitSignal.rateLimitReached.emit(e1.getRateLimitDuration());
+ }
+ logger.log(logger.LOW, "*** EDAM System Excepton syncLocalTags getting remote Tag List");
+ status.message.emit(tr("Error: ") +e1);
+ logger.log(logger.LOW, e1.toString());
+ error = true;
+ } catch (TException e1) {
+ logger.log(logger.LOW, "*** EDAM Transaction Excepton syncLocalTags getting remote Tag List");
+ status.message.emit(tr("Error: ") +e1);
+ logger.log(logger.LOW, e1.toString());
+ error = true;
+ }
+
+ int sequence;
+
+ if (badTagSync == null)
+ badTagSync = new HashMap<String,String>();
+ else
+ badTagSync.clear();
+
+ Tag enTag = findNextTag();
+
+ // This is a hack. Sometimes this function goes flookey and goes into a
+ // perpetual loop. This causes NeverNote to flood Evernote's servers.
+ // This is a safety valve to prevent unlimited loops.
+ int maxCount = conn.getTagTable().getDirty().size()+10;
+ int loopCount = 0;
+
+ while(enTag!=null && loopCount < maxCount) {
+ loopCount++;
+// if (authRefreshNeeded)
+// if (!refreshConnection())
+// return;
+
+ try {
+ if (enTag.getUpdateSequenceNum() > 0) {
+ logger.log(logger.EXTREME, "Updating tag");
+ sequence = noteStore.updateTag(authToken, enTag);
+ } else {
+
+ // Look for a tag with the same name. If one is found, we don't need
+ // to create another one
+ logger.log(logger.EXTREME, "New tag. Comparing with remote names");
+ boolean found = false;
+ String oldGuid = enTag.getGuid();
+ for (int k=0; k<remoteList.size() && !found && keepRunning; k++) {
+ if (remoteList.get(k).getName().equalsIgnoreCase(enTag.getName())) {
+ conn.getTagTable().updateTagGuid(enTag.getGuid(), remoteList.get(k).getGuid());
+ enTag = remoteList.get(k);
+ logger.log(logger.EXTREME, "Matching tag name found");
+ found = true;
+ }
+ }
+ if (!found)
+ enTag = noteStore.createTag(authToken, enTag);
+ else
+ enTag.setUpdateSequenceNum(noteStore.updateTag(authToken,enTag));
+ sequence = enTag.getUpdateSequenceNum();
+ if (!oldGuid.equals(enTag.getGuid())) {
+ logger.log(logger.EXTREME, "Updating tag guid");
+ conn.getTagTable().updateTagGuid(oldGuid, enTag.getGuid());
+ }
+ }
+ logger.log(logger.EXTREME, "Updating tag sequence number");
+ conn.getTagTable().updateTagSequence(enTag.getGuid(), sequence);
+ logger.log(logger.EXTREME, "Resetting tag dirty flag");
+ conn.getTagTable().resetDirtyFlag(enTag.getGuid());
+ logger.log(logger.EXTREME, "Emitting sequence number to the main thread.");
+ updateSequenceNumber = sequence;
+ conn.getSyncTable().setUpdateSequenceNumber(updateSequenceNumber);
+ } catch (EDAMUserException e) {
+ logger.log(logger.LOW, "*** EDAM User Excepton syncLocalTags: " +enTag.getName());
+ logger.log(logger.LOW, e.toString());
+ badTagSync.put(enTag.getGuid(),null);
+ error = true;
+ } catch (EDAMSystemException e) {
+ if (e.getErrorCode() == EDAMErrorCode.RATE_LIMIT_REACHED) {
+ limitSignal.rateLimitReached.emit(e.getRateLimitDuration());
+ }
+ logger.log(logger.LOW, "** EDAM System Excepton syncLocalTags: " +enTag.getName());
+ logger.log(logger.LOW, e.toString());
+ badTagSync.put(enTag.getGuid(),null);
+ error = true;
+ } catch (EDAMNotFoundException e) {
+ logger.log(logger.LOW, "*** EDAM Not Found Excepton syncLocalTags: " +enTag.getName());
+ logger.log(logger.LOW, e.toString());
+ badTagSync.put(enTag.getGuid(),null);
+ error = true;
+ } catch (TException e) {
+ logger.log(logger.LOW, "*** EDAM TExcepton syncLocalTags: " +enTag.getName());
+ logger.log(logger.LOW, e.toString());
+ badTagSync.put(enTag.getGuid(),null);
+ error = true;
+ }
+
+ // Find the next tag
+ logger.log(logger.EXTREME, "Finding next tag");
+ enTag = findNextTag();
+ }
+ logger.log(logger.HIGH, "Leaving SyncRunner.syncLocalTags");
+ }
+ private void syncLocalLinkedNotebooks(Client noteStore) {
+ logger.log(logger.HIGH, "Entering SyncRunner.syncLocalLinkedNotebooks");
+
+ List<String> list = conn.getLinkedNotebookTable().getDirtyGuids();
+ for (int i=0; i<list.size(); i++) {
+ LinkedNotebook book = conn.getLinkedNotebookTable().getNotebook(list.get(i));
+ try {
+ noteStore.updateLinkedNotebook(authToken, book);
+ } catch (EDAMUserException e) {
+ logger.log(logger.LOW, "*** EDAM User Excepton syncLocalLinkedNotebooks");
+ status.message.emit(tr("Error: ") +e);
+ logger.log(logger.LOW, e.toString());
+ error = true;
+ e.printStackTrace();
+ } catch (EDAMNotFoundException e) {
+ logger.log(logger.LOW, "*** EDAM Not Found Excepton syncLocalLinkedNotebooks");
+ status.message.emit(tr("Error: ") +e);
+ logger.log(logger.LOW, e.toString());
+ error = true;
+ e.printStackTrace();
+ } catch (EDAMSystemException e) {
+ if (e.getErrorCode() == EDAMErrorCode.RATE_LIMIT_REACHED) {
+ limitSignal.rateLimitReached.emit(e.getRateLimitDuration());
+ }
+ logger.log(logger.LOW, "*** EDAM System Excepton syncLocalLinkedNotebooks");
+ status.message.emit(tr("Error: ") +e);
+ logger.log(logger.LOW, e.toString());
+ error = true;
+ e.printStackTrace();
+ } catch (TException e) {
+ logger.log(logger.LOW, "*** EDAM TExcepton syncLocalLinkedNotebooks");
+ status.message.emit(tr("Error: ") +e);
+ logger.log(logger.LOW, e.toString());
+ error = true;
+ e.printStackTrace();
+ }
+ }
+ logger.log(logger.HIGH, "Leaving SyncRunner.syncLocalLinkedNotebooks");
+ }
+ // Sync Saved Searches with Evernote
+ private void syncLocalSavedSearches(Client noteStore) {
+ logger.log(logger.HIGH, "Entering SyncRunner.syncLocalSavedSearches");
+ List<SavedSearch> remoteList = new ArrayList<SavedSearch>();
+ status.message.emit(tr("Sending saved searches."));
+
+ logger.log(logger.EXTREME, "Getting saved searches to compare with local");
+ try {
+ remoteList = noteStore.listSearches(authToken);
+ } catch (EDAMUserException e1) {
+ logger.log(logger.LOW, "*** EDAM User Excepton syncLocalTags getting remote saved search List");
+ status.message.emit(tr("Error: ") +e1);
+ logger.log(logger.LOW, e1.toString());
+ error = true;
+ } catch (EDAMSystemException e1) {
+ if (e1.getErrorCode() == EDAMErrorCode.RATE_LIMIT_REACHED) {
+ limitSignal.rateLimitReached.emit(e1.getRateLimitDuration());
+ }
+ logger.log(logger.LOW, "*** EDAM System Excepton syncLocalTags getting remote saved search List");
+ status.message.emit(tr("Error: ") +e1);
+ logger.log(logger.LOW, e1.toString());
+ error = true;
+ } catch (TException e1) {
+ logger.log(logger.LOW, "*** EDAM Transaction Excepton syncLocalTags getting remote saved search List");
+ status.message.emit(tr("Error: ") +e1);
+ logger.log(logger.LOW, e1.toString());
+ error = true;
+ }
+
+ List<SavedSearch> searches = conn.getSavedSearchTable().getDirty();
+ int sequence;
+ // Sync the local notebooks with Evernote's
+ logger.log(logger.EXTREME, "Beginning to send saved searches");
+ for (int i=0; i<searches.size() && keepRunning; i++) {
+
+// if (authRefreshNeeded)
+// if (!refreshConnection())
+// return;
+
+ SavedSearch enSearch = searches.get(i);
+ try {
+ if (enSearch.getUpdateSequenceNum() > 0)
+ sequence = noteStore.updateSearch(authToken, enSearch);
+ else {
+ logger.log(logger.EXTREME, "New saved search found.");
+ // Look for a tag with the same name. If one is found, we don't need
+ // to create another one
+ boolean found = false;
+ logger.log(logger.EXTREME, "Matching remote saved search names with local");
+ for (int k=0; k<remoteList.size() && !found && keepRunning; k++) {
+ if (remoteList.get(k).getName().equalsIgnoreCase(enSearch.getName())) {
+ enSearch = remoteList.get(k);
+ found = true;
+ logger.log(logger.EXTREME, "Matching saved search found");
+ sequence = enSearch.getUpdateSequenceNum();
+ }
+ }
+
+ String oldGuid = enSearch.getGuid();
+ if (!found)
+ enSearch = noteStore.createSearch(authToken, enSearch);
+ sequence = enSearch.getUpdateSequenceNum();
+ logger.log(logger.EXTREME, "Updating tag guid in local database");
+ conn.getSavedSearchTable().updateSavedSearchGuid(oldGuid, enSearch.getGuid());
+ }
+ logger.log(logger.EXTREME, "Updating tag sequence in local database");
+ conn.getSavedSearchTable().updateSavedSearchSequence(enSearch.getGuid(), sequence);
+ logger.log(logger.EXTREME, "Resetting tag dirty flag");
+ conn.getSavedSearchTable().resetDirtyFlag(enSearch.getGuid());
+ logger.log(logger.EXTREME, "Emitting sequence number to the main thread.");
+ updateSequenceNumber = sequence;
+ conn.getSyncTable().setUpdateSequenceNumber(updateSequenceNumber);
+ } catch (EDAMUserException e) {
+ logger.log(logger.LOW, "*** EDAM User Excepton syncLocalTags");
+ logger.log(logger.LOW, e.toString());
+ error = true;
+ } catch (EDAMSystemException e) {
+ if (e.getErrorCode() == EDAMErrorCode.RATE_LIMIT_REACHED) {
+ limitSignal.rateLimitReached.emit(e.getRateLimitDuration());
+ }
+ logger.log(logger.LOW, "** EDAM System Excepton syncLocalTags");
+ logger.log(logger.LOW, e.toString());
+ error = true;
+ } catch (EDAMNotFoundException e) {
+ logger.log(logger.LOW, "*** EDAM Not Found Excepton syncLocalTags");
+ logger.log(logger.LOW, e.toString());
+ error = true;
+ } catch (TException e) {
+ logger.log(logger.LOW, "*** EDAM TExcepton syncLocalTags");
+ logger.log(logger.LOW, e.toString());
+ error = true;
+ }
+ }
+
+ logger.log(logger.HIGH, "Entering SyncRunner.syncLocalSavedSearches");
+ }
+
+ // Sync evernote changes with local database
+ private void syncRemoteToLocal(Client noteStore) {
+ logger.log(logger.HIGH, "Entering SyncRunner.syncRemoteToLocal");
+
+ List<Note> dirtyNotes = conn.getNoteTable().getDirty();
+ dirtyNoteGuids = new ArrayList<String>();\r
+ for (int i=0; i<dirtyNotes.size() && keepRunning; i++) {
+ dirtyNoteGuids.add(dirtyNotes.get(i).getGuid());
+ }
+
+ int chunkSize = 10;
+ SyncChunk chunk = null;
+ boolean fullSync = false;
+ boolean more = true;
+
+ if (updateSequenceNumber == 0)
+ fullSync = true;
+
+ status.message.emit(tr("Downloading 0% complete."));
+
+ while(more && keepRunning) {
+
+// if (authRefreshNeeded)
+// if (!refreshConnection())
+// return;
+
+ int sequence = updateSequenceNumber;
+ try {
+// conn.beginTransaction();
+ logger.log(logger.EXTREME, "Getting chunk from Evernote");
+ chunk = noteStore.getSyncChunk(authToken, sequence, chunkSize, fullSync);
+ logger.log(logger.LOW, "Chunk High Sequence: " +chunk.getChunkHighUSN());
+ } catch (EDAMUserException e) {
+ error = true;
+ e.printStackTrace();
+ status.message.emit(e.getMessage());
+ } catch (EDAMSystemException e) {
+ if (e.getErrorCode() == EDAMErrorCode.RATE_LIMIT_REACHED) {
+ limitSignal.rateLimitReached.emit(e.getRateLimitDuration());
+ }
+ error = true;
+ e.printStackTrace();
+ status.message.emit(e.getMessage());
+ } catch (TException e) {
+ error = true;
+ e.printStackTrace();
+ status.message.emit(e.getMessage());
+ }
+ if (error || chunk == null)
+ return;
+
+
+
+ syncRemoteTags(chunk.getTags());
+ syncRemoteSavedSearches(chunk.getSearches());
+ syncRemoteNotebooks(chunk.getNotebooks());
+ syncRemoteNotes(noteStore, chunk.getNotes(), fullSync, authToken);
+ syncRemoteResources(noteStore, chunk.getResources());
+ syncRemoteLinkedNotebooks(chunk.getLinkedNotebooks());
+
+ // Signal about any updated notes to invalidate the cache
+ for (int i=0; i<chunk.getNotesSize(); i++)
+ noteSignal.noteChanged.emit(chunk.getNotes().get(i).getGuid(), null);
+ syncExpungedNotes(chunk);
+
+
+ // Check for more notes
+ if (chunk.getChunkHighUSN() <= updateSequenceNumber)
+ more = false;
+ if (error)
+ more = false;
+ logger.log(logger.EXTREME, "More notes? " +more);
+
+
+ // Save the chunk sequence number
+ if (!error && chunk.getChunkHighUSN() > 0 && keepRunning) {
+ logger.log(logger.EXTREME, "emitting sequence number to main thread");
+ updateSequenceNumber = chunk.getChunkHighUSN();
+ conn.getSyncTable().setLastSequenceDate(chunk.getCurrentTime());
+ conn.getSyncTable().setUpdateSequenceNumber(updateSequenceNumber);
+// conn.commitTransaction();
+ }
+
+
+ if (more) {
+ long pct = chunk.getChunkHighUSN() * 100;
+ conn.getSyncTable().setLastSequenceDate(chunk.getCurrentTime());
+ pct = pct/evernoteUpdateCount;
+ status.message.emit(tr("Downloading ") +new Long(pct).toString()+tr("% complete."));
+ }
+// conn.commitTransaction();
+ }
+ logger.log(logger.HIGH, "Leaving SyncRunner.syncRemoteToLocal");
+ }
+ // Sync expunged notes
+ private void syncExpungedNotes(SyncChunk chunk) {
+ // Do the local deletes
+ logger.log(logger.EXTREME, "Doing local deletes");
+ List<String> guid = chunk.getExpungedNotes();
+ if (guid != null) {
+ for (int i=0; i<guid.size() && keepRunning; i++) {
+ String notebookGuid = "";
+ Note localNote = conn.getNoteTable().getNote(guid.get(i), false, false, false, false, false);
+ if (localNote != null) {
+ conn.getNoteTable().updateNoteSequence(guid.get(i), 0);
+ notebookGuid = localNote.getNotebookGuid();
+ }
+ // If the note is in a local notebook (which means we moved it) or if the \r
+ // note returned is null (which means it is already deleted or flagged expunged) \r
+ // we delete it.\r
+ if (!conn.getNotebookTable().isNotebookLocal(notebookGuid) || localNote == null) {\r
+ logger.log(logger.EXTREME, "Expunging local note from database");
+ conn.getNoteTable().expungeNote(guid.get(i), true, false);
+ }
+ }
+ }
+ guid = chunk.getExpungedNotebooks();
+ if (guid != null)
+ for (int i=0; i<guid.size() && keepRunning; i++) {
+ logger.log(logger.EXTREME, "Expunging local notebook from database");
+ conn.getNotebookTable().expungeNotebook(guid.get(i), false);
+ }
+ guid = chunk.getExpungedTags();
+ if (guid != null)
+ for (int i=0; i<guid.size() && keepRunning; i++) {
+ logger.log(logger.EXTREME, "Expunging tags from local database");
+ conn.getTagTable().expungeTag(guid.get(i), false);
+ }
+ guid = chunk.getExpungedSearches();
+ if (guid != null)
+ for (int i=0; i<guid.size() && keepRunning; i++) {
+ logger.log(logger.EXTREME, "Expunging saved search from local database");
+ conn.getSavedSearchTable().expungeSavedSearch(guid.get(i), false);
+ }
+ guid = chunk.getExpungedLinkedNotebooks();
+ if (guid != null)
+ for (int i=0; i<guid.size() && keepRunning; i++) {
+ logger.log(logger.EXTREME, "Expunging linked notebook from local database");
+ conn.getLinkedNotebookTable().expungeNotebook(guid.get(i), false);
+ }
+
+ }
+ // Sync remote tags
+ private void syncRemoteTags(List<Tag> tags) {
+ logger.log(logger.EXTREME, "Entering SyncRunner.syncRemoteTags");
+ if (tags != null) {
+ for (int i=0; i<tags.size() && keepRunning; i++) {
+ String oldGuid;
+ oldGuid = conn.getTagTable().findTagByName(tags.get(i).getName());
+ if (oldGuid != null && !tags.get(i).getGuid().equalsIgnoreCase(oldGuid))
+ conn.getTagTable().updateTagGuid(oldGuid, tags.get(i).getGuid());
+ conn.getTagTable().syncTag(tags.get(i), false);
+ }
+ }
+ logger.log(logger.EXTREME, "Leaving SyncRunner.syncRemoteTags");
+ }
+ // Sync remote saved searches
+ private void syncRemoteSavedSearches(List<SavedSearch> searches) {
+ logger.log(logger.EXTREME, "Entering SyncRunner.syncSavedSearches");
+ if (searches != null) {
+ for (int i=0; i<searches.size() && keepRunning; i++) {
+ String oldGuid;
+ oldGuid = conn.getSavedSearchTable().findSavedSearchByName(searches.get(i).getName());
+ if (oldGuid != null && !searches.get(i).getGuid().equalsIgnoreCase(oldGuid))
+ conn.getSavedSearchTable().updateSavedSearchGuid(oldGuid, searches.get(i).getGuid());
+ conn.getSavedSearchTable().syncSavedSearch(searches.get(i), false);
+ }
+ }
+ logger.log(logger.EXTREME, "Leaving SyncRunner.syncSavedSearches");
+ }
+ // Sync remote linked notebooks
+ private void syncRemoteLinkedNotebooks(List<LinkedNotebook> books) {
+ logger.log(logger.EXTREME, "Entering SyncRunner.syncLinkedNotebooks");
+ if (books != null) {
+ for (int i=0; i<books.size() && keepRunning; i++) {
+ conn.getLinkedNotebookTable().updateNotebook(books.get(i), false);
+ }
+ }
+ logger.log(logger.EXTREME, "Leaving SyncRunner.syncLinkedNotebooks");
+ }
+ // Sync remote Notebooks 2
+ private void syncRemoteNotebooks(List<Notebook> notebooks) {
+ logger.log(logger.EXTREME, "Entering SyncRunner.syncRemoteNotebooks");
+ if (notebooks != null) {
+ for (int i=0; i<notebooks.size() && keepRunning; i++) {
+ String oldGuid;
+ oldGuid = conn.getNotebookTable().findNotebookByName(notebooks.get(i).getName());
+ if (oldGuid != null && !conn.getNotebookTable().isNotebookLocal(oldGuid) && !notebooks.get(i).getGuid().equalsIgnoreCase(oldGuid))
+ conn.getNotebookTable().updateNotebookGuid(oldGuid, notebooks.get(i).getGuid());
+ conn.getNotebookTable().syncNotebook(notebooks.get(i), false);
+
+ // Synchronize shared notebook information
+// if (notebooks.get(i).getSharedNotebookIdsSize() > 0) {
+// conn.getSharedNotebookTable().expungeNotebookByGuid(notebooks.get(i).getGuid(), false);
+// for (int j=0; j<notebooks.get(i).getSharedNotebookIdsSize(); j++) {
+// syncRemoteSharedNotebook(notebooks.get(i).getGuid(), notebooks.get(i).getSharedNotebookIds().get(j), authToken);
+// }
+// }
+ }
+ }
+ logger.log(logger.EXTREME, "Leaving SyncRunner.syncRemoteNotebooks");
+ }
+ // Sync remote shared notebook
+// private void syncRemoteSharedNotebook(String guid, Long id, String token) {
+// List<SharedNotebook> books = noteStore.getSharedNotebookByAuth(authToken);
+// }
+ // Sync remote Resources
+ private void syncRemoteResources(Client noteStore, List<Resource> resource) {
+ logger.log(logger.EXTREME, "Entering SyncRunner.syncRemoteResources");
+ if (resource != null) {
+ for (int i=0; i<resource.size() && keepRunning; i++) {
+ syncRemoteResource(noteStore, resource.get(i), authToken);
+ }
+ }
+ logger.log(logger.EXTREME, "Leaving SyncRunner.syncRemoteResources");
+ }
+ // Sync remote resource
+ private void syncRemoteResource(Client noteStore, Resource resource, String authToken) {
+ // This is how the logic for this works.
+ // 1.) If the resource is not in the local database, we add it.
+ // 2.) If a copy of the resource is in the local database and the note isn't dirty, we update the local copy
+ // 3.) If a copy of the resource is in the local databbase and it is dirty and the hash doesn't match, we ignore it because there
+ // is a conflict. The note conflict should get a copy of the resource at that time.
+
+ Note n = conn.getNoteTable().getNote(resource.getNoteGuid(), false, false, false, false, false);
+ if (n!=null) {
+ logger.log(logger.HIGH, "Resource for note " +n.getGuid() +" : " +n.getTitle());
+ }
+ boolean saveNeeded = false;
+ /* #1 */ Resource r = getEvernoteResource(noteStore, resource.getGuid(), true,true,true, authToken);
+ Resource l = conn.getNoteTable().noteResourceTable.getNoteResource(r.getGuid(), false);
+ if (l == null) {
+ logger.log(logger.HIGH, "Local resource not found");
+ saveNeeded = true;
+ } else {
+ /* #2 */ boolean isNoteDirty = conn.getNoteTable().isNoteDirty(r.getNoteGuid());
+ if (!isNoteDirty) {
+ logger.log(logger.HIGH, "Local resource found, but is not dirty");
+ saveNeeded = true;
+ } else {
+ /* #3 */ String remoteHash = "";
+ if (r != null && r.getData() != null && r.getData().getBodyHash() != null)
+ remoteHash = byteArrayToHexString(r.getData().getBodyHash());
+ String localHash = "";
+ if (l != null && l.getData() != null && l.getData().getBodyHash() != null)
+ remoteHash = byteArrayToHexString(l.getData().getBodyHash());
+
+ if (localHash.equalsIgnoreCase(remoteHash))
+ saveNeeded = true;
+ }
+ }
+
+ logger.log(logger.HIGH, "Resource save needed: " +saveNeeded);
+ if (saveNeeded)
+ conn.getNoteTable().noteResourceTable.updateNoteResource(r, false);
+ if (r.getMime().equalsIgnoreCase("application/vnd.evernote.ink"))
+ downloadInkNoteImage(r.getGuid(), authToken);
+
+
+ }
+ // Sync remote notes
+ private void syncRemoteNotes(Client noteStore, List<Note> note, boolean fullSync, String token) {