src/cx/fbn/nevernote/threads/ENRelatedNotesRunner.java

   1 /*
   2  * This file is part of NeighborNote
   3  * Copyright 2013 Yuki Takahashi
   4  *
   5  * This file may be licensed under the terms of of the
   6  * GNU General Public License Version 2 (the ``GPL'').
   7  *
   8  * Software distributed under the License is distributed
   9  * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
  10  * express or implied. See the GPL for the specific language
  11  * governing rights and limitations.
  12  *
  13  * You should have received a copy of the GPL along with this
  14  * program. If not, go to http://www.gnu.org/licenses/gpl.html
  15  * or write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18 */
  19
  20 package cx.fbn.nevernote.threads;
  21
  22 import java.util.ArrayList;
  23 import java.util.List;
  24 import java.util.concurrent.LinkedBlockingQueue;
  25
  26 import com.evernote.edam.error.EDAMNotFoundException;
  27 import com.evernote.edam.error.EDAMSystemException;
  28 import com.evernote.edam.error.EDAMUserException;
  29 import com.evernote.edam.limits.Constants;
  30 import com.evernote.edam.notestore.RelatedQuery;
  31 import com.evernote.edam.notestore.RelatedResult;
  32 import com.evernote.edam.notestore.RelatedResultSpec;
  33 import com.evernote.edam.type.Note;
  34 import com.evernote.thrift.TException;
  35 import com.trolltech.qt.core.QMutex;
  36 import com.trolltech.qt.core.QObject;
  37
  38 import cx.fbn.nevernote.Global;
  39 import cx.fbn.nevernote.signals.ENRelatedNotesSignal;
  40 import cx.fbn.nevernote.utilities.ApplicationLogger;
  41 import cx.fbn.nevernote.utilities.Pair;
  42
  43 public class ENRelatedNotesRunner extends QObject implements Runnable{
  44
  45         private final ApplicationLogger logger;
  46         private final SyncRunner syncRunner;
  47         public volatile ENRelatedNotesSignal enRelatedNotesSignal;
  48         public QMutex mutex;
  49         private volatile boolean keepRunning;
  50         private volatile LinkedBlockingQueue<String> workQueue;
  51         private volatile LinkedBlockingQueue<Pair<String, List<String>>> resultQueue;   // ペア<元ノートguid, 関連ノートguidリスト>を溜めておくキュー
  52
  53         public ENRelatedNotesRunner(SyncRunner syncRunner, ApplicationLogger logger) {
  54                 this.logger = logger;
  55                 this.syncRunner = syncRunner;
  56                 this.enRelatedNotesSignal = new ENRelatedNotesSignal();
  57                 this.mutex = new QMutex();
  58                 this.keepRunning = true;
  59                 this.workQueue = new LinkedBlockingQueue<String>();
  60                 this.resultQueue = new LinkedBlockingQueue<Pair<String, List<String>>>();
  61         }
  62
  63         @Override
  64         public void run() {
  65                 thread().setPriority(Thread.MIN_PRIORITY);
  66
  67                 logger.log(logger.MEDIUM, "ENRelatedNotesスレッド開始");
  68                 while (keepRunning) {
  69                         try {
  70                                 String work = workQueue.take();
  71                                 mutex.lock();
  72                                 if (work.startsWith("GET")) {
  73                                         String guid = work.replace("GET ", "");
  74                                         logger.log(logger.EXTREME, "Evernote関連ノート取得開始 guid = " + guid);
  75
  76                                         List<Note> relatedNotes = getENRelatedNotes(guid);
  77
  78                                         Pair<String, List<String>> resultPair = new Pair<String, List<String>>();
  79                                         resultPair.setFirst(guid);
  80                                         if (relatedNotes == null) {                             // 取得に失敗
  81                                                 logger.log(logger.EXTREME, "Evernote関連ノートの取得に失敗");
  82                                         } else if (relatedNotes.isEmpty()) {    // このノートにEvernote関連ノートは存在しない
  83                                                 logger.log(logger.EXTREME, "Evernote関連ノートの取得に成功　関連ノートは存在しなかった");
  84                                                 resultPair.setSecond(new ArrayList<String>());
  85                                         } else {                                                                // Evernote関連ノートが存在する
  86                                                 logger.log(logger.EXTREME, "Evernote関連ノートの取得に成功　関連ノートは存在した");
  87                                                 List<String> relatedNoteGuids = new ArrayList<String>();
  88                                                 for (Note relatedNote : relatedNotes) {
  89                                                         relatedNoteGuids.add(relatedNote.getGuid());
  90                                                 }
  91                                                 resultPair.setSecond(relatedNoteGuids);
  92                                         }
  93
  94                                         resultQueue.offer(resultPair);
  95                                         enRelatedNotesSignal.getENRelatedNotesFinished.emit();
  96                                         logger.log(logger.EXTREME, "Evernote関連ノート取得完了 guid = " + guid);
  97                                 } else if (work.startsWith("STOP")) {
  98                                         logger.log(logger.MEDIUM, "ENRelatedNotesスレッド停止");
  99                                         keepRunning = false;
 100                                 }
 101                                 mutex.unlock();
 102                         } catch (InterruptedException e) {
 103                                 // TODO 自動生成された catch ブロック
 104                                 e.printStackTrace();
 105                         }
 106                 }
 107         }
 108
 109         private List<Note> getENRelatedNotes(String guid) {
 110                 RelatedResult result = getENRelatedResult(guid);
 111                 List<Note> relatedNotes = new ArrayList<Note>();
 112
 113                 if (result != null) {
 114                         relatedNotes = result.getNotes();
 115                         return relatedNotes;
 116                 }
 117
 118                 return null;
 119         }
 120
 121         private RelatedResult getENRelatedResult(String guid) {
 122                 if (!Global.isConnected) {
 123                         return null;
 124                 }
 125
 126                 RelatedQuery rquery = new RelatedQuery();
 127                 rquery.setNoteGuid(guid);
 128                 RelatedResultSpec resultSpec = new RelatedResultSpec();
 129                 resultSpec.setMaxNotes(Constants.EDAM_RELATED_MAX_NOTES);
 130                 if (syncRunner != null && syncRunner.localNoteStore != null) {
 131                         try {
 132                                 RelatedResult result = syncRunner.localNoteStore.findRelated(syncRunner.authToken, rquery, resultSpec);
 133                                 return result;
 134                         } catch (EDAMUserException e) {
 135                                 logger.log(logger.HIGH, "Evernote関連ノート取得中に例外発生：EDAMUserException");
 136                         } catch (EDAMSystemException e) {
 137                                 logger.log(logger.HIGH, "Evernote関連ノート取得中に例外発生：EDAMSystemException");
 138                         } catch (EDAMNotFoundException e) {
 139                                 logger.log(logger.HIGH, "Evernote関連ノート取得中に例外発生：EDAMnotFoundException guid = " + guid);
 140                         } catch (TException e) {
 141                                 logger.log(logger.HIGH, "Evernote関連ノート取得中に例外発生：TException");
 142                         }
 143                 }
 144                 return null;
 145         }
 146
 147         public boolean isKeepRunning() {
 148                 return keepRunning;
 149         }
 150
 151         public void setKeepRunning(boolean keepRunning) {
 152                 this.keepRunning = keepRunning;
 153         }
 154
 155         public synchronized boolean addGuid(String guid) {
 156                 if (workQueue.offer("GET " + guid)) {
 157                         return true;
 158                 }
 159
 160                 return false;
 161         }
 162
 163         public synchronized boolean addStop() {
 164                 if (workQueue.offer("STOP")) {
 165                         return true;
 166                 }
 167                 return false;
 168         }
 169
 170         public synchronized Pair<String, List<String>> getENRelatedNoteGuids() {
 171                 try {
 172                         return resultQueue.take();
 173                 } catch (InterruptedException e) {
 174                         // TODO 自動生成された catch ブロック
 175                         e.printStackTrace();
 176                 }
 177
 178                 return null;
 179         }
 180 }