Wallet Functionalities

The page provides instructions on how to add wallet/Bolt functionalities to the sample app.

Wallet Directories

The following directories lie inside the android studio project:

├── ui
│   ├── bolt
│   │   ├── BoltFragment.kt(Handles UI logic,click and views.)
│   │   ├── BoltViewModel.kt(Handles data sources and core api methods.)
│   │   ├── SortEnum.kt(Wrapper to efficiently use sort while getting transactions)
│   │   └── TransactionsAdapter.kt(Adapter for recycler view in BoltFragment)
│   │   └── TransactionBottomSheetFragment.kt(Bottom Sheet for displaying the transaction value)
│   ├── CreateWalletFragment.kt (Creates wallet for a user at first time)
UI/bolt/BoltFragment.kt
package org.zus.bolt.helloworld.ui.bolt

import android.app.AlertDialog
import android.content.ClipboardManager
import android.content.Context.CLIPBOARD_SERVICE
import android.os.Bundle
import android.util.Log
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.view.WindowManager
import android.widget.TextView
import androidx.activity.OnBackPressedCallback
import androidx.fragment.app.Fragment
import androidx.lifecycle.ViewModelProvider
import androidx.navigation.fragment.findNavController
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.viewbinding.ViewBindings
import com.google.android.material.textfield.TextInputLayout
import com.google.android.material.textview.MaterialTextView
import kotlinx.coroutines.*
import org.zus.bolt.helloworld.R
import org.zus.bolt.helloworld.databinding.BoltFragmentBinding
import org.zus.bolt.helloworld.ui.mainactivity.MainViewModel
import zcncore.Zcncore

public const val TAG_BOLT: String = "BoltFragment"

class BoltFragment : Fragment() {

    private lateinit var binding: BoltFragmentBinding
    private lateinit var mainViewModel: MainViewModel
    private lateinit var boltViewModel: BoltViewModel
    private lateinit var onBackPressedCallback: OnBackPressedCallback
    override fun onCreateView(
        inflater: LayoutInflater, container: ViewGroup?,
        savedInstanceState: Bundle?,
    ): View {

        binding = BoltFragmentBinding.inflate(inflater, container, false)
        mainViewModel = ViewModelProvider(requireActivity())[MainViewModel::class.java]
        boltViewModel = ViewModelProvider(this)[BoltViewModel::class.java]


        binding.zcnBalance.text = getString(R.string.zcn_balance, "0")
        binding.zcnDollar.text = getString(R.string.zcn_dollar, 0.0f)

        boltViewModel.isRefreshLiveData.observe(viewLifecycleOwner) { isRefresh ->
            binding.swipeRefresh.isRefreshing = isRefresh
        }

         CoroutineScope(Dispatchers.Main).launch {
            val usd = boltViewModel.zcnToUsd(1.0)
            binding.zcnDollarValue.text = getString(R.string._1_zcn_0_0001_usd, 1.0, usd)
        }

        onBackPressedCallback = object : OnBackPressedCallback(true) {
            override fun handleOnBackPressed() {
                if (boltViewModel.isRefreshLiveData.value != true) {
                    findNavController().popBackStack()
                }
            }
        }
        requireActivity().onBackPressedDispatcher.addCallback(
            viewLifecycleOwner,
            onBackPressedCallback
        )
        boltViewModel.isRefreshLiveData.observe(viewLifecycleOwner) { isRefresh ->
            if (!isRefresh) {
                requireActivity().runOnUiThread {
                    requireActivity().window.clearFlags(WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE)
                }
            } else {
                requireActivity().runOnUiThread {
                    requireActivity().window.setFlags(
                        WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE,
                        WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE
                    )
                }
            }
            binding.swipeRefresh.isRefreshing = isRefresh
        }
        
/* Setting the adapters. */
        val transactionsAdapter = TransactionsAdapter(requireContext(), childFragmentManager, listOf())
        binding.rvTransactions.layoutManager = LinearLayoutManager(requireContext())
        binding.rvTransactions.adapter = transactionsAdapter

        boltViewModel.transactionsLiveData.observe(viewLifecycleOwner) { transactions ->
            transactionsAdapter.transactions = transactions
            transactionsAdapter.notifyDataSetChanged()
        }
        boltViewModel.balanceLiveData.observe(viewLifecycleOwner) { balance ->
            binding.zcnBalance.text = getString(R.string.zcn_balance, balance)
            CoroutineScope(Dispatchers.Main).launch {
                val dollar = boltViewModel.zcnToUsd(balance.toDouble())
                try {
                    binding.zcnDollar.text = getString(R.string.zcn_dollar, dollar)
                } catch (e: Exception) {
                    Log.e(TAG_BOLT, "onCreateView: ${e.message}")
                }
            }
        }

        /* Receive token faucet transaction. */
        binding.mFaucet.setOnClickListener {
            /* updating the balance after 3 seconds.*/
            CoroutineScope(Dispatchers.IO).launch {
                boltViewModel.receiveFaucet()
                val calls = async {
                    updateBalance()
                    updateTransactions()
                }
                awaitAll(calls)
            }
        }

        /* Send token to an address. */
        binding.msendToken.setOnClickListener {
            val builder = AlertDialog.Builder(requireContext())
            val dialogView = LayoutInflater.from(requireContext())
                .inflate(R.layout.send_transaction_dialog, null)
            builder.setTitle("Send Token")
                .setView(dialogView)
                .setPositiveButton("Send") { _, _ ->
                    val address =
                        dialogView.findViewById<TextView>(R.id.et_to_client_id).text.toString()
                    val amount = dialogView.findViewById<TextView>(R.id.amount).text.toString()
                    if (amount.isBlank() || amount.toDouble() <= 0.0f) {
                        val amountTIL = ViewBindings.findChildViewById<TextInputLayout>(
                            dialogView,
                            R.id.amountTextInputLayout
                        )
                        amountTIL?.error = "Amount should be greater than 0"
                    } else {
                        CoroutineScope(Dispatchers.IO).launch {
                            boltViewModel.sendTransaction(address, amount)
                        }
                    }
                }
                .setNegativeButton("Cancel") { dialog, _ ->
                    dialog.cancel()
                }
            builder.create().show()
        }

        binding.mreceiveToken.setOnClickListener {
            val builder = AlertDialog.Builder(requireContext())
            val dialogView = LayoutInflater.from(requireContext())
                .inflate(R.layout.receive_transaction_dialog, null)
            dialogView.findViewById<MaterialTextView>(R.id.tv_receiver_client_id).text =
                buildString {
                    append(
                        mainViewModel.wallet?.mClientId?.substring(
                            0,
                            16
                        )
                    )
                    append("...")
                    append(mainViewModel.wallet?.mClientId?.substring(mainViewModel.wallet?.mClientId?.length!! - 16))
                }
            builder.setTitle("Receive Token")
                .setView(dialogView)
                .setCancelable(true)
                .setNeutralButton("Copy Client ID") { _, _ ->
                    //copy to clipboard
                    var clipboard =
                        requireActivity().getSystemService(CLIPBOARD_SERVICE) as ClipboardManager
                    clipboard.setPrimaryClip(
                        android.content.ClipData.newPlainText(
                            "text",
                            mainViewModel.wallet?.mClientId
                        )
                    )
                }
            builder.create().show()
        }

        binding.swipeRefresh.setOnRefreshListener {
            CoroutineScope(Dispatchers.IO).launch {
                val calls = async {
                    updateTransactions()
                    updateBalance()
                }
                awaitAll(calls)
            }
        }
        return binding.root
    }

    /* Get transactions. */
    private suspend fun updateTransactions() {
        boltViewModel.getTransactions(
            fromClientId = mainViewModel.wallet?.mClientId ?: "",
            toClientId = "",
            sortOrder = Sort.getSort(SortEnum.DESC),
            limit = 20,
            offset = 0
        )
    }

    private suspend fun updateBalance() {
        boltViewModel.getWalletBalance()
    }
}
  • Line 3 to 23 import all the libraries (zcncore(gosdk) is imported at line 23 ) required to built WalletUI fragment for the App.

  • Line 26 defines BoltFragment class to define structure for UI.

  • Line 31 to 34 defines variable required to hold values for binding application data to view ,main home page UI of the app wallet UI and .

  • Line 35 defines method for creating a view

    • a) override fun. This is just us overriding the function called onCreateView that is inherited from the Fragment class.

    • b) onCreateView() method is called and the view returned from this method will be the one shown to the user.

    • c) ViewModelProvider instance is used with Fragments to hold activity data,The ViewModelProvider exists when you first request a View until the Activity is finished and destroyed.

    • d) In line 41 and 42, all the ViewModelProvider activities are assigned to mainViewModel and BoltViewModel variables to hold and manage UI-related data .

    • Line 45 and 46 binds zcn balance in tokens and usd via gosdk methods.

    • Line 52 to 67 make use of coroutunes to handle execution for back button in the sample app .A coroutine can suspend its execution at some point and resume later on.

    • Line 85 to line 103 makes use of the TransactionAdapter to make changes to live transaction balance and change it based on app actions and finally binds to UI. See gif here.

  • Line 106 to 116 adds a mouse click Listener when a user clicks on faucet button .See faucet gif here.

  • Line 119 to 145 adds a mouse click Listener when a user click on send button, provides a new dialog to provide sender details and update wallet balance after sending .See send button in the gif for reference.

  • Line 147 to 189 adds a mouse click Listener when a user click on recieve button, provides a new dialog to provide reciever details and update wallet balance after receiving .See recieve button in gif for reference

  • Line 192 to 200 defines function to update transactions in real time .It is updated by all the on mouse click listeners defined above and details are sorted via sortenum .

  • Line 202 to 205 defines function to update wallet balance .It is utilized and called by onmouseclick listeners defined above after their desired functionality is reached.

UI/bolt/BoltViewModel.kt
package org.zus.bolt.helloworld.ui.bolt

import android.util.Log
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import com.google.gson.Gson
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import org.zus.bolt.helloworld.models.bolt.BalanceModel
import org.zus.bolt.helloworld.models.bolt.TransactionModel
import zcncore.GetInfoCallback
import zcncore.Transaction
import zcncore.TransactionCallback
import zcn.Zcn

class BoltViewModel : ViewModel() {
    val transactionsLiveData: MutableLiveData<List<TransactionModel>> = MutableLiveData()
    var balanceLiveData = MutableLiveData<String>()
    val isRefreshLiveData = MutableLiveData<Boolean>()

    private val getInfoCallback = GetInfoCallback { p0, p1, p2, p3 ->
        isRefreshLiveData.postValue(false)
        Log.i(TAG_BOLT, "onInfoAvailable: ")
        Log.i(TAG_BOLT, "onInfoAvailable: p0 $p0")
        Log.i(TAG_BOLT, "onInfoAvailable: p1 $p1")
        Log.i(TAG_BOLT, "onInfoAvailable: p2 $p2")
        Log.i(TAG_BOLT, "onInfoAvailable: p3 $p3")
    }

    suspend fun sendTransaction(to: String, amount: String) {
        withContext(Dispatchers.IO) {
            isRefreshLiveData.postValue(true)
            Zcncore.newTransaction(transactionCallback, /* gas = */ "0", /* nonce = */ getNonce())
                .send(
                    /* receiver address = */ to,
                    /* amount = */ Zcncore.convertToValue(amount.toDouble()).toString(),
                    /* notes = */ "Hello world! sending tokens."
                )
        }
    }

    suspend fun receiveFaucet() {
        withContext(Dispatchers.IO) {
            isRefreshLiveData.postValue(true)
            Zcncore.newTransaction(transactionCallback, /* gas = */ "0",/* nonce = */getNonce())
                .executeSmartContract(
                    /* faucet address = */ "6dba10422e368813802877a85039d3985d96760ed844092319743fb3a76712d3",
                    /* method name = */ "pour",
                    /* inputs = */ "{}",
                    /* amount = */ Zcncore.convertToValue(1.0)
                )
        }
    }

    /* Use this callback while making a transaction. */
    private val transactionCallback = object : TransactionCallback {
        override fun onAuthComplete(p0: Transaction?, p1: Long) {
            // confirmation of successful authentication of the transaction.
        }

        override fun onTransactionComplete(transaction: Transaction?, status: Long) {
            // confirmation of successful transaction.
            isRefreshLiveData.postValue(false)
            if (status == 0L) {
                // Successful status of the transaction.
            }
        }

        override fun onVerifyComplete(p0: Transaction?, p1: Long) {
            // confirmation of successful verification of the transaction.
            isRefreshLiveData.postValue(false)
        }
    }

    suspend fun getWalletBalance() {
        return withContext(Dispatchers.IO) {
            try {
                isRefreshLiveData.postValue(true)
                Zcncore.getBalance { status, value, info ->
                    isRefreshLiveData.postValue(false)
                    if (status == 0L) {
                        Gson().fromJson(info, BalanceModel::class.java).let { balanceModel ->
                            balanceLiveData.postValue(
                                Zcncore.convertToToken(balanceModel.balance).toString()
                            )
                        }
                    } else {
                        print("Error: $info")
                        balanceLiveData.postValue("")
                    }
                }
            } catch (e: Exception) {
                isRefreshLiveData.postValue(false)
                print("Error: $e")
//                Zcncore.newTransaction(transactionCallback, /* gas = */ "0", /* nonce = */ getNonce())
                balanceLiveData.postValue("")
            }
        }
    }

    suspend fun getTransactions(
        toClientId: String,
        fromClientId: String,
        sortOrder: String,
        limit: Long,
        offset: Long,
    ) {
        withContext(Dispatchers.IO) {
            isRefreshLiveData.postValue(true)
            Zcncore.getTransactions(
                toClientId,
                fromClientId,
/*block hash optional =*/"",
                sortOrder,
                limit,
                offset
            ) { _, _, json, error ->
                isRefreshLiveData.postValue(false)
                if (error.isEmpty() && !json.isNullOrBlank() && json.isNotEmpty()) {
                    val transactions = Gson().fromJson(json, Array<TransactionModel>::class.java)
                    this@BoltViewModel.transactionsLiveData.postValue(transactions.toList())
                } else {
                    Log.e(TAG_BOLT, "getTransactions: $error")
                }
            }
        }
    }

    suspend fun getBlobbers() {
        withContext(Dispatchers.IO) {
            isRefreshLiveData.postValue(true)
            Zcncore.getBlobbers(getInfoCallback, /* limit */ 20, /* offset */ 0, true)
        }
    }

    private suspend fun getNonce(): Long {
        return withContext(Dispatchers.IO) {
            var nonceGlobal: Long = 0L
            Zcncore.getNonce { status, nonce, error ->
                if (status == 0L && error == null) {
                    // nonce is a string
                    // nonce = "0"
                    nonceGlobal = nonce
                }
            }
            return@withContext nonceGlobal
        }
    }
    
    suspend fun zcnToUsd(zcn: Double): Double {
        return withContext(Dispatchers.IO) {
            return@withContext try {
                Zcncore.convertTokenToUSD(zcn)
            } catch (e: Exception) {
                0.0
            }
        }
    }

    suspend fun tokenToUsd(token: Long): Double {
        return withContext(Dispatchers.IO) {
            return@withContext try {
                Zcncore.convertTokenToUSD(Zcncore.convertToToken(token))
            } catch (e: Exception) {
                0.0
            }
        }
    }
      
}

Describing Code

  • Line 16 defines a BoltViewModelclass that utilizes the zcncore libraries and provide the following functionalities for BoltFragment

  • Line 30 to 40 sendTransaction function : Send Tokens to Wallet Transactions via gosdk newTransaction function.

  • Line 42 to 53 receiveFaucet function : Receive Tokens to Wallet Transactions via gosdk newTransaction function.

  • Line 75 to 99 getWalletBalance function ; Get Wallet Balance via gosdk getbalance function

  • Line 101 to 127 getTransactions function : Get Transactions List via gosdk getTransactions function.

  • Line 129 to 134 getBlobbers function : Get list of storage providers/blobbers via gosdk getBlobbers function

  • Line 136 to 146 getNonce function: Retrieves a 32-bit number that miners use as a base for transaction hash calculations.Retrieved via gosdk getNonce function.

  • Line 150 to 158 zcnToUsd function : Convert ZCN value to USD. Utilized gosdk convertTokentoUSD.

  • Line 160 to 168 tokenToUsd function : Convert ZCN Token to USD.Utilized gosdk convertTokentoUSD and ConvertToToken.

UI/bolt/SortEnum.kt
package org.zus.bolt.helloworld.ui.bolt

enum class SortEnum {
    ASC,
    DESC
}

object Sort {
    fun getSort(sortEnum: SortEnum): String {
        return when (sortEnum) {
            SortEnum.ASC -> "asc"
            SortEnum.DESC -> "desc"
        }
    }
}

Desccribing Code

  • Line 3 to 6 defines enum class SortEnum which has two value Ascending and Descending.

  • Line 8 to 9 defines object of Sort EnumClass which can be used later to filter any details in ascending or descending order.

UI/bolt/TransactionsAdapter.kt
package org.zus.bolt.helloworld.ui.bolt

import android.app.Activity
import android.content.Context
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.ImageButton
import android.widget.TextView
import android.widget.Toast
import androidx.fragment.app.Fragment
import androidx.fragment.app.FragmentManager
import androidx.recyclerview.widget.RecyclerView
import org.zus.bolt.helloworld.R
import org.zus.bolt.helloworld.models.bolt.TransactionModel
import org.zus.bolt.helloworld.utils.Utils.Companion.getConvertedTime
import org.zus.bolt.helloworld.utils.Utils.Companion.getShortFormattedString

class TransactionsAdapter(
    var context: Context,
    var childFragmentManager: FragmentManager,
    var transactions: List<TransactionModel>,
) : RecyclerView.Adapter<TransactionsAdapter.ViewHolder>() {

    class ViewHolder(view: View) : RecyclerView.ViewHolder(view) {
        val tvHash: TextView
        val tvDateTime: TextView
        val btnCopyHash: ImageButton

        init {
            tvHash = view.findViewById(R.id.tv_hash)
            tvDateTime = view.findViewById(R.id.tv_date_time)
            btnCopyHash = view.findViewById(R.id.btn_copy_hash)
        }
    }

    holder.tvDateTime.text =
            (transactions[position].creation_date / 1000000000).getConvertedTime()

        holder.btnCopyHash.setOnClickListener {
            val clipboard =
                context.getSystemService(Context.CLIPBOARD_SERVICE) as android.content.ClipboardManager
            val clip = android.content.ClipData.newPlainText(
                "Transaction Hash",
                transactions[position].hash
            )
            clipboard.setPrimaryClip(clip)
            Toast.makeText(
                context,
                "Transaction Hash Copied ${transactions[position].hash.getShortFormattedString()}",
                Toast.LENGTH_SHORT
            ).show()
        }

        holder.itemView.setOnClickListener {
            val transactionBottomSheetFragment =
                TransactionBottomSheetFragment(transactions[position])
            transactionBottomSheetFragment.show(
                childFragmentManager,
                "TransactionBottomSheetFragment"
            )
        }
    }

Describing Code:

  • Line 3 to 17 import packages required to segment sample app into multiple, independent screens that are hosted within an activity and to create a Recycler View in app. To understand more about RecyclerView read here

  • Line 19 defines a class TransactionsAdapter

    • In the class following variables are defined( Line 20 to 23 )

      • context: to hold context for TransactionsView.

      • childFragmentManager : An array to hold transaction object details

      • Another class 'ViewHolder' is defined which holds a recyclable view of transaction details.(Line 25 to 35)

  • Line 37 overrides the method onCreateViewHoldercreates a new ViewHolder and initializes some private fields to be used by RecyclerView.

  • Line 43 overrides onBindViewHolder method which is Called by RecyclerView to display the transaction data at the specified position.Time stamps are deermined for the transaction and its details are listed in a dialog box as per TransactionBottomSheetFragment.kt

UI/bolt/TransactionBottomSheetFragment.kt
package org.zus.bolt.helloworld.ui.bolt

import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import com.google.android.material.bottomsheet.BottomSheetDialogFragment
import org.zus.bolt.helloworld.R
import org.zus.bolt.helloworld.databinding.GenericBottomSheetDetailsFragmentBinding
import org.zus.bolt.helloworld.databinding.RowDetailsListItemBinding
import org.zus.bolt.helloworld.models.bolt.TransactionModel
import org.zus.bolt.helloworld.models.selectapp.DetailsListModel
import org.zus.bolt.helloworld.models.selectapp.DetailsModel
import org.zus.bolt.helloworld.ui.selectapp.DetailsListAdapter
import org.zus.bolt.helloworld.utils.Utils.Companion.getConvertedDateTime

class TransactionBottomSheetFragment(
    private val transactionModel: TransactionModel,
) : BottomSheetDialogFragment() {
    private lateinit var binding: GenericBottomSheetDetailsFragmentBinding


    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {
        binding = GenericBottomSheetDetailsFragmentBinding.inflate(inflater, container, false)

        binding.tvPageTitle.text = getString(R.string.transaction_details)

        val signatureAndHashes = DetailsListModel(
            title = "Signature and Hashes",
            detailsList = listOf(
                DetailsModel(
                    title = "Transaction Hash: ${transactionModel.hash}",
                    value = transactionModel.hash,
                    showArrowButton = false
                ),
                DetailsModel(
                    title = "Block Hash: ${transactionModel.block_hash}",
                    value = transactionModel.block_hash,
                    showArrowButton = false
                ),
                DetailsModel(
                    title = "Output Hash: ${transactionModel.output_hash}",
                    value = transactionModel.output_hash,
                    showArrowButton = false
                ),
                DetailsModel(
                    title = "Client Id: ${transactionModel.client_id}",
                    value = transactionModel.client_id,
                    showArrowButton = false
                ),
                DetailsModel(
                    title = "To Client Id: ${transactionModel.to_client_id}",
                    value = transactionModel.to_client_id,
                    showArrowButton = false
                ),
                DetailsModel(
                    title = "Signature: ${transactionModel.signature}",
                    value = transactionModel.signature,
                    showArrowButton = false
                ),
            )
        )

        val amountDetails = DetailsListModel(
            title = "Amount Details",
            detailsList = listOf(
                DetailsModel(
                    title = "Status: ${transactionModel.status}",
                    value = transactionModel.status.toString(),
                    showArrowButton = false
                ),
                DetailsModel(
                    title = "Value: ${transactionModel.value}",
                    value = transactionModel.value.toString(),
                    showArrowButton = false
                ),
                DetailsModel(
                    title = "Fee: ${transactionModel.fee}",
                    value = transactionModel.fee.toString(),
                    showArrowButton = false
                ),
                DetailsModel(
                    title = "Date: ${(transactionModel.creation_date / 1000000000).getConvertedDateTime()}",
                    value = transactionModel.creation_date.toString(),
                    showArrowButton = false
                )
            )
        )

        val explorer = DetailsListModel(
            title = "Explorer",
            detailsList = listOf(
                DetailsModel(
                    title = "Explorer: https://demo.atlus.cloud/transaction-details/${transactionModel.hash}",
                    value = "https://demo.atlus.cloud/transaction-details/${transactionModel.hash}",
                    showArrowButton = true
                )
            )
        )

        val detailsList = listOf(signatureAndHashes, amountDetails, explorer)

        binding.detailsListView.removeAllViews()

        for (detailsModel in detailsList) {
            val rowDetailsListItemBindings = RowDetailsListItemBinding.inflate(
                LayoutInflater.from(requireActivity()),
                binding.detailsListView,
                false
            )
            rowDetailsListItemBindings.tvDetails.text = detailsModel.title
            rowDetailsListItemBindings.detailsListView.adapter = DetailsListAdapter(
                requireActivity(),
                detailsModel.detailsList
            )

            binding.detailsListView.addView(rowDetailsListItemBindings.root)
        }

        return binding.root
    }
}

Describing Code :

  • Line 1 to 15 import packages required to create a bottom sheet dialog box for the sample app trasnsaction view.To learn more about bottomsheets check here.

  • Line 17 defines a class TransactionBottomSheetFragment

  • Line 18 to 20 defines the variables required for binding the view to transaction data via Transaction Model.

  • Line 23 to 66 overrides the method onCreateView and defines how different transaction details in the dialog box should be displayed .

  • Inside onCreateView Line 68 to 92 defines how transaction details should be displayed in the dialog box .

  • Line 105 to 122 inflates the view with the above defined bottomsheet dialog specs.

UI/CreateWalletFragment.kt
package org.zus.bolt.helloworld.ui

import android.os.Bundle
import android.util.Log
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.Fragment
import androidx.lifecycle.ViewModelProvider
import androidx.navigation.fragment.findNavController
import com.google.gson.Gson
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
import org.zus.bolt.helloworld.R
import org.zus.bolt.helloworld.databinding.CreateWalletFragmentBinding
import org.zus.bolt.helloworld.models.bolt.WalletModel
import org.zus.bolt.helloworld.ui.mainactivity.MainViewModel
import org.zus.bolt.helloworld.ui.vult.VultViewModel
import org.zus.bolt.helloworld.utils.Utils
import org.zus.bolt.helloworld.utils.ZcnSDK
import zcncore.Zcncore
import java.io.FileNotFoundException
import java.util.*

public const val TAG_CREATE_WALLET: String = "CreateWalletFragment"

class CreateWalletFragment : Fragment() {

    private lateinit var binding: CreateWalletFragmentBinding
    private lateinit var mainViewModel: MainViewModel
    private lateinit var vultViewModel: VultViewModel


    override fun onCreateView(
        inflater: LayoutInflater, container: ViewGroup?,
        savedInstanceState: Bundle?,
    ): View? {

        binding = CreateWalletFragmentBinding.inflate(inflater, container, false)
        mainViewModel = ViewModelProvider(requireActivity())[MainViewModel::class.java]
        vultViewModel = ViewModelProvider(requireActivity())[VultViewModel::class.java]
        return binding.root

    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        binding.progressView.visibility = View.VISIBLE

        try {
            val walletJsonStringFromFile = Utils(requireContext()).readWalletFromFileJSON()

            Log.i(
                TAG_CREATE_WALLET,
                "walletJsonStringFromFile: ${walletJsonStringFromFile.isNullOrBlank()}"
            )
            if (walletJsonStringFromFile.isBlank() || walletJsonStringFromFile.isEmpty()) {
                Zcncore.createWallet { status, walletJson, error ->
                    if (status == 0L) {
                        Log.i(TAG_CREATE_WALLET, "New Wallet created successfully")
                        Utils(requireContext()).saveWalletAsFile(walletJson)
                        processWallet(walletJson)