Examples with Cw20BalanceGrpcTask wannabit.io.cosmostaion.task.gRpcTask.Cw20BalanceGrpcTask used on opensource projects

Example 1 with Cw20BalanceGrpcTask

use of wannabit.io.cosmostaion.task.gRpcTask.Cw20BalanceGrpcTask in project cosmostation-android by cosmostation.

the class BaseActivity method onTaskResponse.

@Override
public void onTaskResponse(TaskResult result) {
    // WLog.w("onTaskResponse " + result.taskType + "   " + mTaskCount);
    if (isFinishing())
        return;
    if (result.taskType == BaseConstant.TASK_PUSH_STATUS_UPDATE) {
        if (result.isSuccess) {
            mAccount = getBaseDao().onUpdatePushEnabled(mAccount, (boolean) result.resultData);
        }
        invalidateOptionsMenu();
        return;
    } else if (result.taskType == BaseConstant.TASK_FETCH_PRICE_INFO) {
        if (result.isSuccess && result.resultData != null) {
            getBaseDao().mPrices.clear();
            ArrayList<Price> tempPrice = new ArrayList<>();
            tempPrice = (ArrayList<Price>) result.resultData;
            for (Price price : tempPrice) {
                getBaseDao().mPrices.add(price);
            }
        }
    }
    mTaskCount--;
    if (result.taskType == BaseConstant.TASK_FETCH_ACCOUNT) {
        mAccount = getBaseDao().onSelectAccount(getBaseDao().getLastUser());
        getBaseDao().mBalances = getBaseDao().onSelectBalance(mAccount.id);
    // WLog.w("getBaseDao().mBalances " + getBaseDao().mBalances.size());
    } else if (result.taskType == TASK_FETCH_NODE_INFO) {
        getBaseDao().mNodeInfo = (NodeInfo) result.resultData;
        mTaskCount = mTaskCount + 1;
        new StationParamInfoTask(getBaseApplication(), this, mBaseChain, getBaseDao().getChainId()).executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
    } else if (result.taskType == TASK_FETCH_OKEX_ALL_VALIDATORS) {
        ArrayList<Validator> allValis = (ArrayList<Validator>) result.resultData;
        if (allValis != null) {
            getBaseDao().mAllValidators = allValis;
        }
    } else if (result.taskType == BaseConstant.TASK_FETCH_BNB_TOKENS) {
        ArrayList<BnbToken> tempTokens = (ArrayList<BnbToken>) result.resultData;
        if (tempTokens != null) {
            for (BnbToken token : tempTokens) {
                token.type = BnbToken.BNB_TOKEN_TYPE_BEP2;
                getBaseDao().mBnbTokens.add(token);
            }
        }
    } else if (result.taskType == BaseConstant.TASK_FETCH_BNB_MINI_TOKENS) {
        ArrayList<BnbToken> tempTokens = (ArrayList<BnbToken>) result.resultData;
        if (tempTokens != null) {
            for (BnbToken token : tempTokens) {
                token.type = BnbToken.BNB_TOKEN_TYPE_MINI;
                getBaseDao().mBnbTokens.add(token);
            }
        }
    } else if (result.taskType == TASK_FETCH_BNB_TICKER) {
        ArrayList<BnbTicker> tempTickers = (ArrayList<BnbTicker>) result.resultData;
        if (tempTickers != null) {
            getBaseDao().mBnbTickers.addAll(tempTickers);
        }
    } else if (result.taskType == TASK_FETCH_BNB_MINI_TICKER) {
        ArrayList<BnbTicker> tempTickers = (ArrayList<BnbTicker>) result.resultData;
        if (tempTickers != null) {
            getBaseDao().mBnbTickers.addAll(tempTickers);
        }
    } else if (result.taskType == TASK_FETCH_BNB_FEES) {
        getBaseDao().mBnbFees.clear();
        if (result.isSuccess && result.resultData != null) {
            getBaseDao().mBnbFees = (ArrayList<ResBnbFee>) result.resultData;
        }
    } else if (result.taskType == TASK_FETCH_OK_ACCOUNT_BALANCE) {
        if (result.isSuccess) {
            getBaseDao().mBalances = getBaseDao().onSelectBalance(mAccount.id);
        }
    // WLog.w("getBaseDao().mBalances " + getBaseDao().mBalances.size());
    } else if (result.taskType == TASK_FETCH_OK_STAKING_INFO) {
        if (result.isSuccess && result.resultData != null) {
            getBaseDao().mOkStaking = (ResOkStaking) result.resultData;
        }
    } else if (result.taskType == TASK_FETCH_OK_UNBONDING_INFO) {
        if (result.isSuccess && result.resultData != null) {
            getBaseDao().mOkUnbonding = ((ResOkUnbonding) result.resultData);
        }
    } else if (result.taskType == TASK_FETCH_OK_TOKEN_LIST) {
        if (result.isSuccess && result.resultData != null) {
            getBaseDao().mOkTokenList = ((ResOkTokenList) result.resultData);
        }
    } else if (result.taskType == TASK_FETCH_OK_DEX_TICKERS) {
        if (result.isSuccess && result.resultData != null) {
            getBaseDao().mOkTickersList = ((ResOkTickersList) result.resultData);
        }
    } else // gRPC callback
    if (result.taskType == TASK_GRPC_FETCH_NODE_INFO) {
        tendermint.p2p.Types.NodeInfo tempNodeInfo = (tendermint.p2p.Types.NodeInfo) result.resultData;
        if (tempNodeInfo != null) {
            getBaseDao().mGRpcNodeInfo = tempNodeInfo;
            mTaskCount = mTaskCount + 5;
            new StationParamInfoTask(getBaseApplication(), this, mBaseChain, getBaseDao().getChainIdGrpc()).executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
            new StationIbcPathsTask(getBaseApplication(), this, mBaseChain, getBaseDao().getChainIdGrpc()).executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
            new StationIbcTokensTask(getBaseApplication(), this, mBaseChain, getBaseDao().getChainIdGrpc()).executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
            new MintScanAssetsTask(getBaseApplication(), this, mBaseChain).executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
            new MintScanCw20AssetsTask(getBaseApplication(), this).executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
        }
    } else if (result.taskType == TASK_GRPC_FETCH_AUTH) {
        Any tempAccount = (Any) result.resultData;
        if (tempAccount != null) {
            getBaseDao().mGRpcAccount = tempAccount;
        }
    } else if (result.taskType == TASK_GRPC_FETCH_BONDED_VALIDATORS) {
        ArrayList<Staking.Validator> bonded = (ArrayList<Staking.Validator>) result.resultData;
        if (bonded != null) {
            getBaseDao().mGRpcTopValidators.addAll(bonded);
        }
    } else if (result.taskType == TASK_GRPC_FETCH_UNBONDED_VALIDATORS) {
        ArrayList<Staking.Validator> unbonded = (ArrayList<Staking.Validator>) result.resultData;
        if (unbonded != null) {
            getBaseDao().mGRpcOtherValidators.addAll(unbonded);
        }
    } else if (result.taskType == TASK_GRPC_FETCH_UNBONDING_VALIDATORS) {
        ArrayList<Staking.Validator> unbonding = (ArrayList<Staking.Validator>) result.resultData;
        if (unbonding != null) {
            getBaseDao().mGRpcOtherValidators.addAll(unbonding);
        }
    } else if (result.taskType == TASK_GRPC_FETCH_BALANCE) {
        ArrayList<CoinOuterClass.Coin> balance = (ArrayList<CoinOuterClass.Coin>) result.resultData;
        if (balance != null && balance.size() > 0) {
            for (CoinOuterClass.Coin coin : balance) {
                if (!coin.getAmount().equals("0")) {
                    getBaseDao().mGrpcBalance.add(new Coin(coin.getDenom(), coin.getAmount()));
                } else {
                    if (coin.getDenom().equalsIgnoreCase(WDp.mainDenom(mBaseChain))) {
                        getBaseDao().mGrpcBalance.add(new Coin(coin.getDenom(), coin.getAmount()));
                    }
                }
            }
        }
        if (getBaseDao().mGrpcBalance.size() <= 0 || getBaseDao().getAvailable(WDp.mainDenom(mBaseChain)).compareTo(BigDecimal.ZERO) <= 0) {
            getBaseDao().mGrpcBalance.add(new Coin(WDp.mainDenom(mBaseChain), "0"));
        }
    } else if (result.taskType == TASK_GRPC_FETCH_DELEGATIONS) {
        ArrayList<Staking.DelegationResponse> delegations = (ArrayList<Staking.DelegationResponse>) result.resultData;
        if (delegations != null) {
            getBaseDao().mGrpcDelegations = delegations;
        }
    } else if (result.taskType == TASK_GRPC_FETCH_UNDELEGATIONS) {
        ArrayList<Staking.UnbondingDelegation> undelegations = (ArrayList<Staking.UnbondingDelegation>) result.resultData;
        if (undelegations != null) {
            getBaseDao().mGrpcUndelegations = undelegations;
        }
    } else if (result.taskType == TASK_GRPC_FETCH_ALL_REWARDS) {
        ArrayList<Distribution.DelegationDelegatorReward> rewards = (ArrayList<Distribution.DelegationDelegatorReward>) result.resultData;
        if (rewards != null) {
            getBaseDao().mGrpcRewards = rewards;
        }
    } else if (result.taskType == TASK_GRPC_FETCH_STARNAME_FEE) {
        if (result.isSuccess && result.resultData != null) {
            getBaseDao().mGrpcStarNameFee = ((starnamed.x.configuration.v1beta1.Types.Fees) result.resultData);
        }
    } else if (result.taskType == TASK_GRPC_FETCH_STARNAME_CONFIG) {
        if (result.isSuccess && result.resultData != null) {
            getBaseDao().mGrpcStarNameConfig = ((starnamed.x.configuration.v1beta1.Types.Config) result.resultData);
        }
    } else if (result.taskType == TASK_GRPC_FETCH_GRAVITY_POOL_LIST) {
        if (result.isSuccess && result.resultData != null) {
            List<Liquidity.Pool> pools = (List<Liquidity.Pool>) result.resultData;
            getBaseDao().mGrpcGravityPools = new ArrayList<Liquidity.Pool>(pools);
        }
    } else if (result.taskType == TASK_GRPC_FETCH_OSMOSIS_POOL_LIST) {
        if (result.isSuccess && result.resultData != null) {
            List<BalancerPool.Pool> pools = (List<BalancerPool.Pool>) result.resultData;
            getBaseDao().mGrpcOsmosisPool = new ArrayList<BalancerPool.Pool>(pools);
        }
    } else // kava
    if (result.taskType == TASK_FETCH_KAVA_INCENTIVE_PARAM) {
        if (result.isSuccess && result.resultData != null) {
            getBaseDao().mIncentiveParam5 = (IncentiveParam) result.resultData;
        }
    } else if (result.taskType == TASK_FETCH_KAVA_INCENTIVE_REWARD) {
        if (result.isSuccess && result.resultData != null) {
            getBaseDao().mIncentiveRewards = (IncentiveReward) result.resultData;
        }
    } else if (result.taskType == TASK_GRPC_FETCH_KAVA_PRICES) {
        if (result.isSuccess && result.resultData != null) {
            ArrayList<QueryOuterClass.CurrentPriceResponse> currentPrices = (ArrayList<QueryOuterClass.CurrentPriceResponse>) result.resultData;
            if (currentPrices != null) {
                for (QueryOuterClass.CurrentPriceResponse response : currentPrices) {
                    getBaseDao().mKavaTokenPrice.put(response.getMarketId(), response);
                }
            }
        }
    } else // mintscan
    if (result.taskType == TASK_FETCH_MINTSCAN_CW20_ASSETS) {
        if (result.isSuccess && result.resultData != null) {
            getBaseDao().mCw20Assets = (ArrayList<Cw20Assets>) result.resultData;
            if (getBaseDao().mCw20Assets != null && getBaseDao().mCw20Assets.size() > 0) {
                for (Cw20Assets assets : getBaseDao().mCw20Assets) {
                    if (assets.chain.equalsIgnoreCase(WDp.getChainNameByBaseChain(mBaseChain))) {
                        mTaskCount = mTaskCount + 1;
                        new Cw20BalanceGrpcTask(getBaseApplication(), this, mBaseChain, mAccount, assets.contract_address).executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
                    }
                }
            }
        }
    }
    if (mTaskCount == 0) {
        if (isGRPC(mBaseChain)) {
            getBaseDao().mGRpcAllValidators.addAll(getBaseDao().mGRpcTopValidators);
            getBaseDao().mGRpcAllValidators.addAll(getBaseDao().mGRpcOtherValidators);
            for (Staking.Validator validator : getBaseDao().mGRpcAllValidators) {
                boolean already = false;
                for (Staking.DelegationResponse delegation : getBaseDao().mGrpcDelegations) {
                    if (delegation.getDelegation().getValidatorAddress().equals(validator.getOperatorAddress())) {
                        already = true;
                        break;
                    }
                }
                for (Staking.UnbondingDelegation undelegation : getBaseDao().mGrpcUndelegations) {
                    if (undelegation.getValidatorAddress().equals(validator.getOperatorAddress())) {
                        already = true;
                        break;
                    }
                }
                if (already)
                    getBaseDao().mGRpcMyValidators.add(validator);
            }
            // WLog.w("mIbcTokens " + getBaseDao().mIbcTokens.size());
            if (getBaseDao().mGRpcNodeInfo == null) {
                Toast.makeText(getBaseContext(), R.string.error_network_error, Toast.LENGTH_SHORT).show();
            } else {
                // WLog.w("mGRpcAccount " + getBaseDao().mGRpcAccount.getTypeUrl());
                if (getBaseDao().mGRpcAccount != null && !getBaseDao().mGRpcAccount.getTypeUrl().contains(Auth.BaseAccount.getDescriptor().getFullName())) {
                    WUtil.onParseVestingAccount(getBaseDao(), mBaseChain);
                }
                ArrayList<Balance> snapBalance = new ArrayList<>();
                for (Coin coin : getBaseDao().mGrpcBalance) {
                    snapBalance.add(new Balance(mAccount.id, coin.denom, coin.amount, Calendar.getInstance().getTime().getTime(), "0", "0"));
                }
                getBaseDao().onUpdateBalances(mAccount.id, snapBalance);
            // WLog.w("getBaseDao().mGRpcNodeInfo " + getBaseDao().mGRpcNodeInfo.getNetwork());
            }
        } else if (mBaseChain.equals(BNB_MAIN)) {
            if (getBaseDao().mNodeInfo == null) {
                Toast.makeText(getBaseContext(), R.string.error_network_error, Toast.LENGTH_SHORT).show();
            }
        // WLog.w("mBnbTokens " + getBaseDao().mBnbTokens.size());
        // WLog.w("mBnbTickers " + getBaseDao().mBnbTickers.size());
        } else if (mBaseChain.equals(OKEX_MAIN)) {
            for (Validator all : getBaseDao().mAllValidators) {
                if (all.status == Validator.BONDED) {
                    getBaseDao().mTopValidators.add(all);
                } else {
                    getBaseDao().mOtherValidators.add(all);
                }
            }
            if (getBaseDao().mOkStaking != null && getBaseDao().mOkStaking.validator_address != null) {
                for (String valAddr : getBaseDao().mOkStaking.validator_address) {
                    for (Validator val : getBaseDao().mAllValidators) {
                        if (val.operator_address.equals(valAddr)) {
                            getBaseDao().mMyValidators.add(val);
                        }
                    }
                }
            }
            if (getBaseDao().mNodeInfo == null) {
                Toast.makeText(getBaseContext(), R.string.error_network_error, Toast.LENGTH_SHORT).show();
            }
        } else {
            getBaseDao().mAllValidators.addAll(getBaseDao().mTopValidators);
            getBaseDao().mAllValidators.addAll(getBaseDao().mOtherValidators);
            for (Validator top : getBaseDao().mAllValidators) {
                boolean already = false;
                for (BondingInfo bond : getBaseDao().mMyDelegations) {
                    if (bond.validator_address.equals(top.operator_address)) {
                        already = true;
                        break;
                    }
                }
                for (UnbondingInfo unbond : getBaseDao().mMyUnbondings) {
                    if (unbond.validator_address.equals(top.operator_address) && !already) {
                        already = true;
                        break;
                    }
                }
                if (already)
                    getBaseDao().mMyValidators.add(top);
            }
            if (getBaseDao().mNodeInfo == null) {
                Toast.makeText(getBaseContext(), R.string.error_network_error, Toast.LENGTH_SHORT).show();
            }
        }
        new StationPriceInfoTask(getBaseApplication(), this, mBaseChain).executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
        // callback with delay fix gRPC  timming issue
        mHandler.postDelayed(new Runnable() {

            @Override
            public void run() {
                if (mFetchCallback != null) {
                    mFetchCallback.fetchFinished();
                }
            }
        }, 300);
    }
}