Das Android Arsenal – FSM

Implementieren Sie als Nächstes die Schnittstelle HAL.StateMachine in Ihrem ViewModel Presenter Controller oder ähnlichem.

Die HAL-Klasse erhält die folgenden Parameter:

• A CoroutineScope (Tipp: Verwenden Sie das eingebaute viewModelScope)
• Ein Anfangszustand
• Eine optionale Kapazität Angeben der Kanalpuffergröße (Standard ist Channel.UNLIMITED)
• Ein optionaler CoroutineDispatcher zum Ausführen der Reduziererfunktion (Standard ist Dispatcher.DEFAULT)
• Eine Reduziererfunktion, suspend (Aktion : A, TransitionTo: (S) -> Unit) -> Unit wobei:
  • suspend : Der Reduzierer wird in einem CoroutineScope ausgeführt, sodass Sie IO und andere Komplexe ausführen können Aufgaben, ohne sich Gedanken über das Blockieren des Hauptthreads zu machen
  • Aktion: A : Die Aktion, die an die Staatsmaschine gesendet wird
  • TransitionTo: (S) -> Unit : Die Funktion, die für die Änderung des Status verantwortlich ist.

Sie sollten alle Aktionen innerhalb der Reduktionsfunktion ausführen. Rufen Sie TransitionTo () auf, wenn Sie den Status ändern müssen (er kann mehrmals aufgerufen werden).

 Klasse  MyViewModel  ( private  val  postRepository :  PostRepository ) :  ViewModel  (),  HAL .  StateMachine  <19459017] MyAction,  MyState 

> {

     überschreiben  val  hal von  HAL  (viewModelScope,  MyState .  Init ) {action, transitionTo  -  > 
 als 
 (Klage) {
             ist  MyAction .  LoadPosts  - > 
 {
                Übergang zu ( MyState .  Laden 

)
                
                 try 
 {
                     //  Sie können Suspend-Funktionen ausführen, ohne den Haupt-Thread zu blockieren. 
 val  posts  = 
 postRepository.getPosts ()
                     //  Und mehrere Zustände pro Aktion ausstrahlen 

                    Übergang zu ( MyState .  PostsLoaded 
 (posts))
                }  catch  ( e :  Exception 
) {
                    Übergang zu ( MyState .  Fehler  ( " Ops, etwas ist schiefgelaufen. " 



)
                }
            }
            
             ist  MyAction .  AddPost  - > 
 {
                 / *  Griffaktion  * / 




            }
        }
    }
} 

Wählen Sie schließlich eine Klasse aus, um Aktionen an Ihre Zustandsmaschine zu senden und Zustandsänderungen zu beobachten. Dies kann eine Aktivität ein Fragment oder eine beliebige andere Klasse sein.

Wenn Sie Wenn Sie einen LiveData-basierten Zustandsbeobachter verwenden möchten (dringend empfohlen, wenn Sie mit Android arbeiten), übergeben Sie einfach Ihren LifecycleOwner an observState () andernfalls verwendet HAL einen standardmäßigen Callback-basierten Zustandsbeobachter (der am besten für reine JVM-Anwendungen geeignet ist).

 Klasse  MyActivity :  AppCompatActivity 

 () {

     privat  val  viewModel von viewModels < MyViewModel 

> ()

     Überschreiben  Spaß  OnCreate  ( SavedInstanceState :  Bundle? 

) {
    
         //  Leichte Ausgabe von Aktionen an Ihre State Machine 


        loadPostsBt.setOnClickListener {
            viewModel  +  MyAction .  LoadPosts 



        }
        
         //  Beobachten und Behandeln von Statusänderungen, die von LiveData unterstützt werden 

        viewModel.observeState (lifecycleOwner  =  this ) {state  - > 
 when 
 (state) {
                 ist  MyState .  Init  - > 

 showWelcomeMessage ()
                
                 ist  MyState .  wird geladen  - > 

 showLoading ()
                
                 ist  MyState .  PostsLoaded  - > 

 showPosts (state.posts)
                
                 ist  MyState .  Fehler  - > 



 showError (state.message)
            }
        }
    }
} 

Benutzerdefinierter StateObserver

Sie können Ihren benutzerdefinierten State Observer einfach erstellen, indem Sie die Schnittstelle StateObserver implementieren: Klasse MyCustomStateObserver < S : 19659014] HAL . Staat > (
     privat val myAwesomeParam : MyAwesomeClass ,
     außer Kraft setzen val observer : ( S ) – > Unit
) : StateObserver < S > {

     Überschreiben Spaß Übergang zu ( NewState : S ) {
         // Machen Sie hier irgendeine Operation und rufen Sie am Ende `observer (newState)` an
         // WICHTIG: Diese Methode wird auf dem Haupt-Thread ausgeführt!
    }
}