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 import android.text.TextUtils;
  22
  23 import androidx.lifecycle.LiveData;
  24 import androidx.lifecycle.MutableLiveData;
  25 import androidx.lifecycle.ViewModel;
  26
  27 import net.ktnx.mobileledger.async.RetrieveTransactionsTask;
  28 import net.ktnx.mobileledger.async.TransactionAccumulator;
  29 import net.ktnx.mobileledger.async.UpdateTransactionsTask;
  30 import net.ktnx.mobileledger.db.Profile;
  31 import net.ktnx.mobileledger.model.Data;
  32 import net.ktnx.mobileledger.model.LedgerAccount;
  33 import net.ktnx.mobileledger.model.LedgerTransaction;
  34 import net.ktnx.mobileledger.model.TransactionListItem;
  35 import net.ktnx.mobileledger.utils.Logger;
  36 import net.ktnx.mobileledger.utils.SimpleDate;
  37
  38 import java.util.ArrayList;
  39 import java.util.List;
  40 import java.util.Locale;
  41
  42 public class MainModel extends ViewModel {
  43     public final MutableLiveData<Integer> foundTransactionItemIndex = new MutableLiveData<>(null);
  44     private final MutableLiveData<Boolean> updatingFlag = new MutableLiveData<>(false);
  45     private final MutableLiveData<String> accountFilter = new MutableLiveData<>();
  46     private final MutableLiveData<List<TransactionListItem>> displayedTransactions =
  47             new MutableLiveData<>(new ArrayList<>());
  48     private final MutableLiveData<String> updateError = new MutableLiveData<>();
  49     private SimpleDate firstTransactionDate;
  50     private SimpleDate lastTransactionDate;
  51     transient private RetrieveTransactionsTask retrieveTransactionsTask;
  52     transient private Thread displayedAccountsUpdater;
  53     private TransactionsDisplayedFilter displayedTransactionsUpdater;
  54     public void scheduleTransactionListReload() {
  55         UpdateTransactionsTask task = new UpdateTransactionsTask();
  56         task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, this);
  57     }
  58     public LiveData<Boolean> getUpdatingFlag() {
  59         return updatingFlag;
  60     }
  61     public LiveData<String> getUpdateError() {
  62         return updateError;
  63     }
  64     public LiveData<List<TransactionListItem>> getDisplayedTransactions() {
  65         return displayedTransactions;
  66     }
  67     public void setDisplayedTransactions(List<TransactionListItem> list) {
  68         displayedTransactions.postValue(list);
  69         Data.lastUpdateTransactionCount.postValue(list.size());
  70     }
  71     public SimpleDate getFirstTransactionDate() {
  72         return firstTransactionDate;
  73     }
  74     public void setFirstTransactionDate(SimpleDate earliestDate) {
  75         this.firstTransactionDate = earliestDate;
  76     }
  77     public MutableLiveData<String> getAccountFilter() {
  78         return accountFilter;
  79     }
  80     public SimpleDate getLastTransactionDate() {
  81         return lastTransactionDate;
  82     }
  83     public void setLastTransactionDate(SimpleDate latestDate) {
  84         this.lastTransactionDate = latestDate;
  85     }
  86     private void applyTransactionFilter(List<LedgerTransaction> list) {
  87         final String accFilter = accountFilter.getValue();
  88         ArrayList<TransactionListItem> newList = new ArrayList<>();
  89
  90         TransactionAccumulator accumulator = new TransactionAccumulator(this);
  91         if (TextUtils.isEmpty(accFilter))
  92             for (LedgerTransaction tr : list)
  93                 newList.add(new TransactionListItem(tr));
  94         else
  95             for (LedgerTransaction tr : list)
  96                 if (tr.hasAccountNamedLike(accFilter))
  97                     newList.add(new TransactionListItem(tr));
  98
  99         displayedTransactions.postValue(newList);
 100     }
 101     public synchronized void scheduleTransactionListRetrieval() {
 102         if (retrieveTransactionsTask != null) {
 103             Logger.debug("db", "Ignoring request for transaction retrieval - already active");
 104             return;
 105         }
 106         Profile profile = Data.getProfile();
 107
 108         retrieveTransactionsTask = new RetrieveTransactionsTask(this, profile);
 109         Logger.debug("db", "Created a background transaction retrieval task");
 110
 111         retrieveTransactionsTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
 112     }
 113     public synchronized void stopTransactionsRetrieval() {
 114         if (retrieveTransactionsTask != null)
 115             retrieveTransactionsTask.cancel(true);
 116         else
 117             Data.backgroundTaskProgress.setValue(null);
 118     }
 119     public void transactionRetrievalDone() {
 120         retrieveTransactionsTask = null;
 121     }
 122     synchronized public void updateDisplayedTransactionsFromWeb(List<LedgerTransaction> list) {
 123         if (displayedTransactionsUpdater != null) {
 124             displayedTransactionsUpdater.interrupt();
 125         }
 126         displayedTransactionsUpdater = new TransactionsDisplayedFilter(this, list);
 127         displayedTransactionsUpdater.start();
 128     }
 129     public void clearUpdateError() {
 130         updateError.postValue(null);
 131     }
 132     public void clearTransactions() {
 133         displayedTransactions.setValue(new ArrayList<>());
 134     }
 135
 136     static class TransactionsDisplayedFilter extends Thread {
 137         private final MainModel model;
 138         private final List<LedgerTransaction> list;
 139         TransactionsDisplayedFilter(MainModel model, List<LedgerTransaction> list) {
 140             this.model = model;
 141             this.list = list;
 142         }
 143         @Override
 144         public void run() {
 145             List<LedgerAccount> newDisplayed = new ArrayList<>();
 146             Logger.debug("dFilter", "waiting for synchronized block");
 147             Logger.debug("dFilter", String.format(Locale.US,
 148                     "entered synchronized block (about to examine %d transactions)", list.size()));
 149             String accNameFilter = model.getAccountFilter()
 150                                         .getValue();
 151
 152             TransactionAccumulator acc = new TransactionAccumulator(model);
 153             for (LedgerTransaction tr : list) {
 154                 if (isInterrupted()) {
 155                     return;
 156                 }
 157
 158                 if (accNameFilter == null || tr.hasAccountNamedLike(accNameFilter)) {
 159                     acc.put(tr, tr.getDate());
 160                 }
 161             }
 162             if (!isInterrupted()) {
 163                 acc.done();
 164             }
 165             Logger.debug("dFilter", "left synchronized block");
 166         }
 167     }
 168 }