I had a working app that does some arithmetic functionality that is out of the scope of the question, then I wanted to add more functionality to it, so i separated the layout into activity and fragment in order to later add other fragments that will do extra functions.

yet when I separated the layout taking some buttons along with a TextView (R.id.Result) to the new fragment, the text property of the TextView still updates as expected, but the display stays the same, always showing the initialization value initially assigned to it on its creation time.

I confirmed that the objects are the same as I expected them to be during runtime verified through logcat, what I need OFC is for the TextView display to update when I change its text property, numberInsertAction is called from the buttons properly and send proper data.

Important Note: below is only the relevant parts of code, it is much larger and I know what you see below can be simplified but it is built this way because of other classes and functionality that aren't shown below, if you need to see or ask about something outside the below code please do, yet again I only included the related part only and removed the business functionality.

Thanks in advance.

just to reiterate: numberInsertAction(view: View) is the entry point/function called by the buttons on the fragment.

MainActivity.kt

class MainActivity : AppCompatActivity(), AddObserverToActivity {
    private lateinit var binding: ActivityMainBinding
    private lateinit var stateManager: StateManager

    override fun onCreate(savedInstanceState: Bundle?) {
        //initialize layout
        super.onCreate(savedInstanceState)
        binding = ActivityMainBinding.inflate(layoutInflater)
        val activityRoot = binding.root
        setContentView(activityRoot)

        stateManager = StateManager()
    }

    override fun addResultObserver(observer: Observer) {
        Log.d(TAG, "addObserver! ${observer.toString()} ${observer::class.toString()}")
        StateManager.addDisplayObserver(observer)
    }

    fun numberInsertAction(view: View) {
        if (view is Button) {
            StateManager.enterDigit(view.text.toString())
        }
    }
}

CalculatorFragment.kt

class CalculatorFragment : Fragment() {

    companion object {
        fun newInstance() = CalculatorFragment()
    }

    private lateinit var binding: FragmentCalculatorBinding
    private lateinit var mainActivityHandle: AddObserverToActivity

    override fun onCreateView(
        inflater: LayoutInflater, container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {
        Log.d(TAG, "onCreateView")
        binding = FragmentCalculatorBinding.inflate(inflater, container, false)
        return inflater.inflate(R.layout.fragment_calculator, container, false)
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        Log.d(TAG, "using on view created")

        mainActivityHandle = context as AddObserverToActivity
        Log.d(TAG, "${binding.Result} ${(binding.Result)::class.simpleName.toString()}")
        Log.d(TAG, mainActivityHandle::class.toString())
        mainActivityHandle.addResultObserver(DisplayPanel(binding.Result))

    }
}

StateManager.kt

class StateManager : Observable() {
    private val displayBuffer = DisplayBuffer(DecimalVariable("0"))

    fun enterDigit(digit: String) {
        Log.d(TAG, "enterDigit: $digit, $currentState")
        displayBuffer.insertDigit(digit)
    }

    fun addDisplayObserver(observer: Observer) {
        Log.d(TAG, "addDisplayObserver: $observer")
        displayBuffer.addObserver(observer)
    }

    private fun doNotify(Notified: Any) {
        Log.d(TAG, "doNotify: $Notified")
        setChanged()
        notifyObservers(Notified)
    }
}

DisplayBuffer.kt

class DisplayBuffer(initializationValue: SomeClass) : Observable() {
    private var initialValue = initializationValue
    private var resultString = "0"

    var value = initialValue
        set(value) {
            Log.d(TAG, "setter: $value")
            field = value
            doNotify()
        }

    fun set(value: String) {
        Log.d(TAG, "set: $value")
        this.value = value as Int
    }

    private fun doNotify() {
        Log.d(TAG, "doNotify")
        setChanged()
        notifyObservers(value.toString())
    }

    fun insertDigit(digit: String) {
        Log.d(TAG, "insertDigit: $digit result: $resultString")
        resultString = resultString   digit

        Log.d(TAG, "new value: $resultString")
        setChanged()
        notifyObservers(resultString)
    }
}

DisplayPanel.kt

class DisplayPanel(calculationTextView: TextView) : Observer {
    private val displayField: TextView = calculationTextView
    private val maxDigits = 16

    private fun setDisplay(text: String) {
        Log.d(TAG, "setDisplay: $text")
        if (text.length <= maxDigits) {
            displayField.text = text
            //displayField.invalidate()
        }
    }

    override fun update(observable: Observable?, targetObjects: Any?) {
        Log.d(TAG, "update: $this $observable, $targetObjects")
        setDisplay(targetObjects as String)
    }
}

CodePudding user response：

Add binding.lifecycleOwner = viewLifecycleOwner in onCreateView or onViewCreated method.

CodePudding user response：

was answered by @Mike M in Comments: In CalculatorFragment, He instructed me to change return inflater.inflate(R.layout.fragment_calculator, container, false) to return binding.root.

as the problem was that this function inflated two instances of the fragment calculator layout and returned the later while it used the former as observer.

to qoute @Mike-M: The inflater.inflate() call is creating a new instance of that layout that is completely separate from the one that FragmentCalculatorBinding is creating and using itself. FragmentCalculatorBinding is inflating the view internally, which is why it is passed the inflater in its inflate() call.