app/src/main/java/net/ktnx/mobileledger/ui/MainModel.java

   1 /*
   2  * Copyright © 2021 Damyan Ivanov.
   3  * This file is part of MoLe.
   4  * MoLe is free software: you can distribute it and/or modify it
   5  * under the term of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 3 of the License, or
   7  * (at your opinion), any later version.
   8  *
   9  * MoLe is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12  * GNU General Public License terms for details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with MoLe. If not, see <https://www.gnu.org/licenses/>.
  16  */
  17
  18 package net.ktnx.mobileledger.ui;
  19
  20 import android.os.AsyncTask;
  21
  22 import androidx.lifecycle.LiveData;
  23 import androidx.lifecycle.MutableLiveData;
  24 import androidx.lifecycle.ViewModel;
  25
  26 import net.ktnx.mobileledger.async.RetrieveTransactionsTask;
  27 import net.ktnx.mobileledger.async.TransactionAccumulator;
  28 import net.ktnx.mobileledger.async.UpdateTransactionsTask;
  29 import net.ktnx.mobileledger.db.Profile;
  30 import net.ktnx.mobileledger.model.Data;
  31 import net.ktnx.mobileledger.model.LedgerAccount;
  32 import net.ktnx.mobileledger.model.LedgerTransaction;
  33 import net.ktnx.mobileledger.model.TransactionListItem;
  34 import net.ktnx.mobileledger.utils.Logger;
  35 import net.ktnx.mobileledger.utils.SimpleDate;
  36
  37 import java.util.ArrayList;
  38 import java.util.List;
  39 import java.util.Locale;
  40
  41 public class MainModel extends ViewModel {
  42     public final MutableLiveData<Integer> foundTransactionItemIndex = new MutableLiveData<>(null);
  43     private final MutableLiveData<Boolean> updatingFlag = new MutableLiveData<>(false);
  44     private final MutableLiveData<String> accountFilter = new MutableLiveData<>(null);
  45     private final MutableLiveData<List<TransactionListItem>> displayedTransactions =
  46             new MutableLiveData<>(new ArrayList<>());
  47     private final MutableLiveData<String> updateError = new MutableLiveData<>();
  48     private SimpleDate firstTransactionDate;
  49     private SimpleDate lastTransactionDate;
  50     transient private RetrieveTransactionsTask retrieveTransactionsTask;
  51     transient private Thread displayedAccountsUpdater;
  52     private TransactionsDisplayedFilter displayedTransactionsUpdater;
  53     public void scheduleTransactionListReload() {
  54         UpdateTransactionsTask task = new UpdateTransactionsTask();
  55         task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, this);
  56     }
  57     public LiveData<Boolean> getUpdatingFlag() {
  58         return updatingFlag;
  59     }
  60     public LiveData<String> getUpdateError() {
  61         return updateError;
  62     }
  63     public LiveData<List<TransactionListItem>> getDisplayedTransactions() {
  64         return displayedTransactions;
  65     }
  66     public void setDisplayedTransactions(List<TransactionListItem> list) {
  67         displayedTransactions.postValue(list);
  68         Data.lastUpdateTransactionCount.postValue(list.size());
  69     }
  70     public SimpleDate getFirstTransactionDate() {
  71         return firstTransactionDate;
  72     }
  73     public void setFirstTransactionDate(SimpleDate earliestDate) {
  74         this.firstTransactionDate = earliestDate;
  75     }
  76     public MutableLiveData<String> getAccountFilter() {
  77         return accountFilter;
  78     }
  79     public SimpleDate getLastTransactionDate() {
  80         return lastTransactionDate;
  81     }
  82     public void setLastTransactionDate(SimpleDate latestDate) {
  83         this.lastTransactionDate = latestDate;
  84     }
  85     public synchronized void scheduleTransactionListRetrieval() {
  86         if (retrieveTransactionsTask != null) {
  87             Logger.debug("db", "Ignoring request for transaction retrieval - already active");
  88             return;
  89         }
  90         Profile profile = Data.getProfile();
  91
  92         retrieveTransactionsTask = new RetrieveTransactionsTask(this, profile);
  93         Logger.debug("db", "Created a background transaction retrieval task");
  94
  95         retrieveTransactionsTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
  96     }
  97     public synchronized void stopTransactionsRetrieval() {
  98         if (retrieveTransactionsTask != null)
  99             retrieveTransactionsTask.cancel(true);
 100         else
 101             Data.backgroundTaskProgress.setValue(null);
 102     }
 103     public void transactionRetrievalDone() {
 104         retrieveTransactionsTask = null;
 105     }
 106     synchronized public void updateDisplayedTransactionsFromWeb(List<LedgerTransaction> list) {
 107         if (displayedTransactionsUpdater != null) {
 108             displayedTransactionsUpdater.interrupt();
 109         }
 110         displayedTransactionsUpdater = new TransactionsDisplayedFilter(this, list);
 111         displayedTransactionsUpdater.start();
 112     }
 113     public void clearUpdateError() {
 114         updateError.postValue(null);
 115     }
 116     public void clearTransactions() {
 117         displayedTransactions.setValue(new ArrayList<>());
 118     }
 119
 120     static class TransactionsDisplayedFilter extends Thread {
 121         private final MainModel model;
 122         private final List<LedgerTransaction> list;
 123         TransactionsDisplayedFilter(MainModel model, List<LedgerTransaction> list) {
 124             this.model = model;
 125             this.list = list;
 126         }
 127         @Override
 128         public void run() {
 129             List<LedgerAccount> newDisplayed = new ArrayList<>();
 130             Logger.debug("dFilter", String.format(Locale.US,
 131                     "entered synchronized block (about to examine %d transactions)", list.size()));
 132             String accNameFilter = model.getAccountFilter()
 133                                         .getValue();
 134
 135             TransactionAccumulator acc = new TransactionAccumulator(accNameFilter);
 136             for (LedgerTransaction tr : list) {
 137                 if (isInterrupted()) {
 138                     return;
 139                 }
 140
 141                 if (accNameFilter == null || tr.hasAccountNamedLike(accNameFilter)) {
 142                     acc.put(tr, tr.getDate());
 143                 }
 144             }
 145
 146             if (isInterrupted())
 147                 return;
 148
 149             acc.publishResults(model);
 150             Logger.debug("dFilter", "transaction list updated");
 151         }
 152     }
 153 }