👧🏿 🎅🏻 🙏🏿 モバイルアプリに入力する増分データを設計する方法 🧛🏼 ⚽️ 🏒

こんにちは！私の名前は私がAndroidのチームリーダーです、ヴィータソコロワでサーフ。

モバイルアプリケーションには、質問やアプリケーションなど、複雑な多段階の入力を伴うフォームがあります。このような機能の設計は、通常、開発者にとって頭痛の種になります。画面間で大量のデータが転送され、ハードリンクが形成されます。つまり、このデータを誰に、誰に、どの順序で送信し、次にどの画面を開くかです。

この記事では、ステップバイステップの機能の作業を整理するための便利な方法を共有します。その助けを借りて、画面間の接続を最小限に抑え、ステップの順序を簡単に変更することができます：新しい画面を追加し、それらの順序とユーザーに表示するロジックを変更します。

*この記事の「機能」という言葉は、論理的に接続され、ユーザーにとって1つの機能を表すモバイルアプリケーションの一連の画面を意味します。

通常、モバイルアプリケーションで質問票に記入し、アプリケーションを送信することは、いくつかの連続した画面で構成されます。ある画面のデータが別の画面で必要になる場合があり、回答によってステップチェーンが変わる場合があります。したがって、ユーザーがデータを「ドラフト」で保存して、後でプロセスに戻ることができるようにすると便利です。

多くの画面が存在する可能性がありますが、実際には、ユーザーは1つの大きなオブジェクトにデータを入力します。この記事では、1つのシナリオである一連の画面を使用して作業を便利に整理する方法を説明します。

ユーザーが仕事に応募してフォームに記入しているとしましょう。途中で中断した場合、入力したデータは下書きに保存されます。ユーザーが記入に戻ると、ドラフトの情報が自動的に質問のフィールドに置き換えられます。ユーザーはすべてを最初から記入する必要はありません。

ユーザーが質問票全体に記入すると、回答がサーバーに送信されます。

アンケートの内容は次のとおりです。

ステップ1-名前、教育の種類、仕事の経験、
ステップ2-研究の場所
ステップ3-あなた自身についての仕事またはエッセイの場所、
ステップ4-欠員が関心を持っている理由。

アンケートは、ユーザーが教育や仕事の経験があるかどうかによって変わります。教育がない場合は、学習場所を埋めるステップを除外します。仕事の経験がない場合は、ユーザーに自分自身について少し書いてもらいます。

設計段階では、いくつかの質問に答える必要があります。

機能スクリプトを柔軟にし、ステップを簡単に追加および削除できるようにする方法。
ステップを開いたときに、必要なデータがすでに入力されていることを確認する方法（たとえば、入り口の[教育]画面は、既知の教育タイプがフィールドの構成を再構築するのを待っています）
最終ステップの後でサーバーに転送するためにデータを共通モデルに集約する方法。
アプリケーションを「ドラフト」に保存して、ユーザーが入力を中断して後で戻ることができるようにする方法。

その結果、次の機能を取得したいと考えています。

例全体がGitHubのリポジトリにあります

明らかな解決策

「フル省電力モード」で機能を開発する場合、最も明白なことは、アプリケーションオブジェクトを作成し、それを画面間で転送して、各ステップで補充することです。

薄い灰色は、特定のステップで不要なデータを示します。同時に、最終的に最終的なアプリケーションに入るために、それらは各画面に送信されます。

もちろん、このすべてのデータを1つのアプリケーションオブジェクトにパックする必要があります。それがどのように見えるか見てみましょう：

class Application(
    val name: String?,
    val surname: String?,
    val educationType : EducationType?,
    val workingExperience: Boolean?
    val education: Education?,
    val experience: Experience?,
    val motivation: List<Motivation>?
)

だが！

このようなオブジェクトを使用して、余分な不要な数のnullチェックでコードをカバーする運命にあります。たとえば、このデータ構造はeducationType、[教育]画面でフィールドがすでに入力されていることを保証するものではありません。

より良くする方法

データ管理を別のオブジェクトに移動することをお勧めします。これにより、各ステップへの入力で必要なnull不可能なデータが提供され、各ステップの結果がドラフトに保存されます。このオブジェクトをインタラクターと呼びます。これは、Robert Martinの純粋なアーキテクチャのユースケースレイヤーに対応し、すべての画面で、さまざまなソース（ネットワーク、データベース、前のステップのデータ、ドラフト提案のデータなど）から収集されたデータを提供します。

私たちのプロジェクトでは、SurfではDaggerを使用しています。いくつかの理由から、インタラクターは通常、スコープが@PerApplicationになります。これにより、インタラクターはアプリケーション内でシングルトンになります。実際、インタラクターは、機能内のシングルトンにすることも、すべてのステップがフラグメントである場合はアクティベーションにすることもできます。それはすべて、アプリケーションの全体的なアーキテクチャに依存します。

さらに例では、アプリケーション全体に対してインタラクターの単一のインスタンスがあると想定します。したがって、スクリプトの終了時にすべてのデータをクリアする必要があります。

タスクを設定するとき、一元化されたデータストレージに加えて、アプリケーションのステップの構成と順序を簡単に管理できるように整理したいと考えました。ユーザーがすでに入力した内容に応じて、ステップを変更できます。したがって、もう1つのエンティティであるシナリオが必要です。彼女の責任範囲は、ユーザーが実行する必要のある手順の順序を維持することです。

スクリプトとインタラクターを使用した段階的な機能の編成により、次のことが可能になります。

スクリプトのステップを変更するのは簡単です。たとえば、実行中にユーザーがリクエストを送信したり、さらに情報が必要な場合にステップを追加したりできないことが判明した場合、さらに作業を重ねることができます。
契約の設定：各ステップの入力と出力に必要なデータ。
ユーザーがすべての画面を完了していない場合は、アプリケーションをドラフトに保存するように整理します。

下書きで保存されたデータを画面に事前入力します。

基本エンティティ

この機能のメカニズムは次のとおりです。

ステップ、入力、および出力を記述するためのモデルのセット。
シナリオ-ユーザーが実行する必要のあるステップ（画面）を説明するエンティティ。
Interactor（ProgressInteractor）-現在アクティブなステップに関する情報を保存し、各ステップの完了後に入力された情報を集約し、新しいステップを開始するための入力データを発行するクラス。
Draft（ApplicationDraft）-入力された情報の保存を担当するクラス。

クラス図は、具体的な実装が継承するすべての基礎となるエンティティを表します。それらがどのように関連しているか見てみましょう。

シナリオエンティティの場合、アプリケーションのシナリオに期待されるロジックを説明するインターフェイスを設定します（必要な手順のリストを含み、必要に応じて前の手順を完了した後に再構築します。

アプリケーションには、多数の連続した画面で構成される複数の機能があり、それぞれが機能や特定のデータに依存しないすべての一般的なロジックを基本クラスProgressInteractorに移動します。

ユーザーが入力したデータをドラフトに保存する必要がない場合があるため、ApplicationDraftは基本クラスに存在しません。したがって、ProgressInteractorの具体的な実装はドラフトで機能します。スクリーンプレゼンターもそれと対話します。

基本クラスの特定の実装のクラス図：

これらのエンティティはすべて、次のように相互に、および画面プレゼンターと相互作用します。

クラスはかなり多いので、記事の最初から機能を使用して各ブロックを個別に分析しましょう。

手順の説明

最初のポイントから始めましょう。手順を説明するエンティティが必要です。

// ,   ,    

interface Step

ジョブアプリケーションの例の機能の場合、手順は次のとおりです。

/**
 *     
 */
enum class ApplicationSteps : Step {
    PERSONAL_INFO,  //  
    EDUCATION,      // 
    EXPERIENCE,     //  
    ABOUT_ME,       //  " "
    MOTIVATION      //     
}

また、各ステップの入力データを記述する必要があります。これを行うために、意図された目的のために封印されたクラスを使用します-限定されたクラス階層を作成します。

コードでどのように見えるか

//   
interface StepInData

//,      
sealed class ApplicationStepInData : StepInData

//     
class EducationStepInData(val educationType: EducationType) : ApplicationStepInData()

//        
class MotivationStepInData(val values: List<Motivation>) : ApplicationStepInData()

同様の方法で出力を説明します。

コードでどのように見えるか

// ,   
interface StepOutData

//,    
sealed class ApplicationStepOutData : StepOutData

//    " "
class PersonalInfoStepOutData(
    val info: PersonalInfo
) : ApplicationStepOutData()

//   ""
class EducationStepOutData(
    val education: Education
) : ApplicationStepOutData()

//    " "
class ExperienceStepOutData(
    val experience: WorkingExperience
) : ApplicationStepOutData()

//   " "
class AboutMeStepOutData(
    val info: AboutMe
) : ApplicationStepOutData()

//   " "
class MotivationStepOutData(
    val motivation: List<Motivation>
) : ApplicationStepOutData()

未記入のアプリケーションをドラフトに保持するという目標を設定しなかった場合は、これに限定することができます。ただし、各画面は空で開くだけでなく、下書きから入力することもできるため、ユーザーがすでに何かを入力している場合は、入力データと下書きからのデータの両方がインタラクターからの入力に送られます。

したがって、このデータをまとめるには、別のモデルのセットが必要です。一部の手順では、入力するための情報を必要とせず、ドラフトからのデータのフィールドのみを提供します

コードでどのように見えるか

/**
 *     +   ,   
 */
interface StepData<I : StepInData, O : StepOutData>

sealed class ApplicationStepData : StepData<ApplicationStepInData,  ApplicationStepOutData> {
    class PersonalInfoStepData(
        val outData: PersonalInfoStepOutData?
    ) : ApplicationStepData()

    class EducationStepData(
        val inData: EducationStepInData,
        val outData: EducationStepOutData?
    ) : ApplicationStepData()

    class ExperienceStepData(
        val outData: ExperienceStepOutData?
    ) : ApplicationStepData()

    class AboutMeStepData(
        val outData: AboutMeStepOutData?
    ) : ApplicationStepData()

    class MotivationStepData(
        val inData: MotivationStepInData,
        val outData: MotivationStepOutData?
    ) : ApplicationStepData()
}

スクリプトに従って行動します

手順の説明と入力/出力データが整理されています。次に、コードの機能スクリプトでこれらの手順の順序を修正しましょう。シナリオエンティティは、現在のステップの順序を管理する責任があります。スクリプトは次のようになります。

/**
 * ,     ,     
 */
interface Scenario<S : Step, O : StepOutData> {
    
    //  
    val steps: List<S>

    /**
     *     
     *        
     */
    fun reactOnStepCompletion(stepOut: O)
}

この例の実装では、スクリプトは次のようになります。

class ApplicationScenario : Scenario<ApplicationStep, ApplicationStepOutData> {

    override val steps: MutableList<ApplicationStep> = mutableListOf(
        PERSONAL_INFO,
        EDUCATION,
        EXPERIENCE,
        MOTIVATION
    )

    override fun reactOnStepCompletion(stepOut: ApplicationStepOutData) {
        when (stepOut) {
            is PersonalInfoStepOutData -> {
                changeScenarioAfterPersonalStep(stepOut.info)
            }
        }
    }

    private fun changeScenarioAfterPersonalStep(personalInfo: PersonalInfo) {
        applyExperienceToScenario(personalInfo.hasWorkingExperience)
        applyEducationToScenario(personalInfo.education)
    }

    /**
     *    -       
     */
    private fun applyEducationToScenario(education: EducationType) {...}

    /**
     *      ,
     *           
     */
    private fun applyExperienceToScenario(hasWorkingExperience: Boolean) {...}
}

スクリプトの変更は双方向である必要があることに注意してください。ステップを削除するとします。ユーザーが戻って別のオプションを選択した場合は、ステップがスクリプトに追加されていることを確認してください。

たとえば、コードは作業経験の有無に対する反応のように見えますか

/**
 *      ,
 *           
 */
private fun applyExperienceToScenario(hasWorkingExperience: Boolean) {
    if (hasWorkingExperience) {
        steps.replaceWith(
            condition = { it == ABOUT_ME },
            newElem = EXPERIENCE
        )
    } else {
        steps.replaceWith(
            condition = { it == EXPERIENCE },
            newElem = ABOUT_ME
        )
    }
}

Interactorのしくみ

ステップバイステップ機能のアーキテクチャの次の構成要素であるインタラクターについて考えてみます。上で述べたように、その主な責任は、ステップ間の切り替えを処理することです。ステップへの入力に必要なデータを提供し、出力データをドラフト要求に集約します。

インタラクターの基本クラスを作成し、すべてのステップバイステップ機能に共通の動作をその中に入れましょう。

/**
 *      
 * S -  
 * I -    
 * O -    
 */
abstract class ProgressInteractor<S : Step, I : StepInData, O : StepOutData>

インタラクターは現在のシナリオで作業する必要があります。シナリオが一連のステップを再構築できるように、次のステップの完了についてインタラクターに通知します。したがって、スクリプトの抽象フィールドを宣言します。これで、特定のインタラクターごとに独自の実装を提供する必要があります。

// ,      
protected abstract val scenario: Scenario<S, O>

インタラクターは、現在アクティブなステップの状態を保存し、次または前のステップに切り替える役割も果たします。目的のフラグメントに切り替えることができるように、ステップの変更をルート画面に迅速に通知する必要があります。これはすべて、イベントブロードキャスト、つまりリアクティブアプローチを使用して簡単に整理できます。また、インタラクターのメソッドは非同期操作（ネットワークまたはデータベースからのデータのロード）を実行することが多いため、RxJavaを使用してインタラクターとプレゼンターと通信します。このツールにまだ慣れていない場合は、この一連の紹介記事をお読みください。

現在のステップとスクリプト内のその位置について画面に必要な情報を説明するモデルを作成しましょう。

/**
 *         
 */
class StepWithPosition<S : Step>(
    val step: S,
    val position: Int,
    val allStepsCount: Int
)

インタラクターでBehaviorSubjectを開始して、新しいアクティブなステップに関する情報を自由に出力してみましょう。

private val stepChangeSubject = BehaviorSubject.create<StepWithPosition<S>>()

画面がこのイベントのストリームをサブスクライブできるように、stepChangeSubjectのラッパーであるパブリック変数stepChangeObservableを作成します。

val stepChangeObservable: Observable<StepWithPosition<S>> = stepChangeSubject.hide()

インタラクターの作業中に、現在アクティブなステップの位置を知る必要があることがよくあります。インタラクターに別のプロパティ（currentStepIndex）を作成し、get（）メソッドとset（）メソッドをオーバーライドすることをお勧めします。これにより、件名からこの情報に簡単にアクセスできます。

コードでどのように見えるか

//   
private var currentStepIndex: Int
    get() = stepChangeSubject.value?.position ?: 0
    set(value) {
        stepChangeSubject.onNext(
            StepWithPosition(
                step = scenario.steps[value],
                position = value,
                allStepsCount = scenario.steps.count()
            )
        )
    }

機能のインタラクターの特定の実装に関係なく、同じように機能する一般的な部分を書いてみましょう。

インタラクターを初期化およびシャットダウンして、子孫で拡張できるようにするためのメソッドを追加しましょう。

初期化とシャットダウンの方法

/**
 *   
 */
@CallSuper
open fun initProgressFeature() {
    currentStepIndex = 0
}

/**
 *   
 */
@CallSuper
open fun closeProgressFeature() {
    currentStepIndex = 0
}

ステップバイステップの機能インタラクターが実行する必要のある機能を追加しましょう。

getDataForStep（ステップ：S）-ステップSへの入力としてデータを提供します。
completeStep（stepOut：O）-O出力を保存し、スクリプトを次のステップに移動します。
toPreviousStep（）-スクリプトを前のステップに移動します。

最初の関数である入力データの処理から始めましょう。各インタラクター自体が、入力データを取得する方法と場所を決定します。これを担当する抽象的なメソッドを追加しましょう：

/**
 *      
 */
protected abstract fun resolveStepInData(step: S): Single<out StepData<I, O>>

特定の画面のプレゼンターの場合、を呼び出すパブリックメソッドを追加します resolveStepInData() :

/**
 *     
 */
fun getDataForStep(step: S): Single<out StepData<I, O>> = resolveStepInData(step)

メソッドをpublicにすることで、このコードを単純化できresolveStepInData()ます。この方法はgetDataForStep()、以下で説明するステップ完了方法との類似性のために追加されています。

ステップを完了するために、同様に、特定の各インタラクターがステップの結果を保存する抽象的なメソッドを作成します。

/**
 *      
 */
protected abstract fun saveStepOutData(stepData: O): Completable

そして公的な方法。その中で、出力情報の保存と呼びます。終了したら、終了ステップからの情報に調整するようにスクリプトに指示します。また、一歩前進していることをサブスクライバーに通知します。

/**
 *       
 */
fun completeStep(stepOut: O): Completable {
    return saveStepOutData(stepOut).doOnComplete {
        scenario.reactOnStepCompletion(stepOut)
        if (currentStepIndex != scenario.steps.lastIndex) {
            currentStepIndex += 1
        }
    }
}

最後に、前のステップに戻るメソッドを実装します。

/**
 *    
 */
fun toPreviousStep() {
    if (currentStepIndex != 0) {
        currentStepIndex -= 1
    }
}

ジョブアプリケーションの例のインタラクターの実装を見てみましょう。覚えているように、この機能ではドラフトリクエストにデータを保存することが重要です。したがって、ApplicationProgressInteractorクラスで、ドラフトの下に追加のフィールドを作成します。

/**
 *    
 */
@PerApplication
class ApplicationProgressInteractor @Inject constructor(
    private val dataRepository: ApplicationDataRepository
) : ProgressInteractor<ApplicationSteps, ApplicationStepInData, ApplicationStepOutData>() {

    //  
    override val scenario = ApplicationScenario()

    //  
    private val draft: ApplicationDraft = ApplicationDraft()

    //  
    fun applyDraft(draft: ApplicationDraft) {
        this.draft.apply {
            clear()
            outDataMap.putAll(draft.outDataMap)
        }
    }
    ...
}

ドラフトクラスはどのように見えるか

/**
 *  
 */
class ApplicationDraft(
    val outDataMap: MutableMap<ApplicationSteps, ApplicationStepOutData> = mutableMapOf()
) : Serializable {
    fun getPersonalInfoOutData() = outDataMap[PERSONAL_INFO] as? PersonalInfoStepOutData
    fun getEducationStepOutData() = outDataMap[EDUCATION] as? EducationStepOutData
    fun getExperienceStepOutData() = outDataMap[EXPERIENCE] as? ExperienceStepOutData
    fun getAboutMeStepOutData() = outDataMap[ABOUT_ME] as? AboutMeStepOutData
    fun getMotivationStepOutData() = outDataMap[MOTIVATION] as? MotivationStepOutData

    fun clear() {
        outDataMap.clear()
    }
}

親クラスで宣言された抽象メソッドの実装を始めましょう。ステップ完了機能から始めましょう-それは非常に簡単です。特定のタイプの出力を目的のキーの下のドラフトに保存します。

/**
 *      
 */
override fun saveStepOutData(stepData: ApplicationStepOutData): Completable {
    return Completable.fromAction {
        when (stepData) {
            is PersonalInfoStepOutData -> {
                draft.outDataMap[PERSONAL_INFO] = stepData
            }
            is EducationStepOutData -> {
                draft.outDataMap[EDUCATION] = stepData
            }
            is ExperienceStepOutData -> {
                draft.outDataMap[EXPERIENCE] = stepData
            }
            is AboutMeStepOutData -> {
                draft.outDataMap[ABOUT_ME] = stepData
            }
            is MotivationStepOutData -> {
                draft.outDataMap[MOTIVATION] = stepData
            }
        }
    }
}

次に、ステップの入力データを取得する方法を見てみましょう。

/**
 *     
 */
override fun resolveStepInData(step: ApplicationStep): Single<ApplicationStepData> {
    return when (step) {
        PERSONAL_INFO -> ...
        EXPERIENCE -> ...
        EDUCATION -> Single.just(
            EducationStepData(
                inData = EducationStepInData(
                    draft.getPersonalInfoOutData()?.info?.educationType
                    ?: error("Not enough data for EDUCATION step")
                ),
                outData = draft.getEducationStepOutData()
            )
        )
        ABOUT_ME -> Single.just(
            AboutMeStepData(
                outData = draft.getAboutMeStepOutData()
            )
        )
        MOTIVATION -> dataRepository.loadMotivationVariants().map { reasonsList ->
            MotivationStepData(
                inData = MotivationStepInData(reasonsList),
                outData = draft.getMotivationStepOutData()
            )
        }
    }
}

ステップを開くとき、2つのオプションがあります：

ユーザーが初めて画面を開きます。
ユーザーはすでに画面に入力しており、下書きにデータを保存しています。

何も入力する必要のないステップについては、ドラフトからの情報（ある場合）を渡します。

 ABOUT_ME -> Single.just(
            AboutMeStepData(
                stepOutData = draft.getAboutMeStepOutData()
            )
        )

前のステップのデータを入力として必要な場合は、ドラフトから引き出します（各ステップの最後に必ず保存します）。同様に、画面全体に使用できるoutDataにデータを転送します。

EDUCATION -> Single.just(
    EducationStepData(
        inData = EducationStepInData(
            draft.getPersonalInfoOutData()?.info?.educationType
            ?: error("Not enough data for EDUCATION step")
        ),
        outData = draft.getEducationStepOutData()
    )
)

さらに興味深い状況もあります。ユーザーがこの特定の欠員に関心を持っている理由を示す必要がある最後のステップでは、考えられる理由のリストをネットワークからダウンロードする必要があります。これは、このアーキテクチャで最も便利な瞬間の1つです。リクエストを送信し、回答を受け取ったら、ドラフトのデータと組み合わせて、入力として画面に送信できます。画面は、データの出所や収集しているソースの数を知る必要さえありません。

MOTIVATION -> {
    dataRepository.loadMotivationVariants().map { reasonsList ->
        MotivationStepData(
            inData = MotivationStepInData(reasonsList),
            outData = draft.getMotivationStepOutData()
        )
    }
}

このような状況は、インタラクターを介して作業することを支持する別の議論です。ステップにデータを提供するために、Webからのダウンロードや前のステップの結果など、いくつかのデータソースを組み合わせる必要がある場合があります。

私たちの方法では、多くのソースからのデータを組み合わせて、必要なものすべてを画面に提供できます。この例でこれが優れている理由を理解するのは難しいかもしれません。実際の形式では（たとえば、ローンを申請する場合）、画面には、多くのリファレンスブック、内部データベースからのユーザーに関する情報、5ステップ前に入力したデータ、および1970年からの最も人気のある逸話のコレクションを送信する必要があります。

プレゼンターコードは、結果（データまたはエラー）のみを生成する別のインタラクターメソッドによって集計が行われる場合、はるかに簡単になります。すべてを探す場所がすぐに明確になれば、開発者は変更や調整を行うのが簡単になります。

しかし、インタラクターにあるのはそれだけではありません。もちろん、すべてのステップが完了したときに、最終的なアプリケーションを送信するメソッドが必要です。最終的なアプリケーションと、「ビルダー」パターンを使用してそれを作成する機能について説明しましょう。

最終申請書提出クラス

/**
 *  
 */
class Application(
    val personal: PersonalInfo,
    val education: Education?,
    val experience: Experience,
    val motivation: List<Motivation>
) {

    class Builder {
        private var personal: Optional<PersonalInfo> = Optional.empty()
        private var education: Optional<Education?> = Optional.empty()
        private var experience: Optional<Experience> = Optional.empty()
        private var motivation: Optional<List<Motivation>> = Optional.empty()

        fun personalInfo(value: PersonalInfo) = apply { personal = Optional.of(value) }
        fun education(value: Education) = apply { education = Optional.of(value) }
        fun experience(value: Experience) = apply { experience = Optional.of(value) }
        fun motivation(value: List<Motivation>) = apply { motivation = Optional.of(value) }

        fun build(): Application {
            return try {
                Application(
                    personal.get(),
                    education.getOrNull(),
                    experience.get(),
                    motivation.get()
                )
            } catch (e: NoSuchElementException) {
                throw ApplicationIsNotFilledException(
                    """Some fields aren't filled in application
                        personal = {${personal.getOrNull()}}
                        experience = {${experience.getOrNull()}}
                        motivation = {${motivation.getOrNull()}}
                    """.trimMargin()
                )
            }
        }
    }
}

アプリケーション自体を送信する方法：

/**
 *  
 */
fun sendApplication(): Completable {
    val builder = Application.Builder().apply {
        draft.outDataMap.values.forEach { data ->
            when (data) {
                is PersonalInfoStepOutData -> personalInfo(data.info)
                is EducationStepOutData -> education(data.education)
                is ExperienceStepOutData -> experience(data.experience)
                is AboutMeStepOutData -> experience(data.info)
                is MotivationStepOutData -> motivation(data.motivation)
            }
        }
    }
    return dataRepository.loadApplication(builder.build())
}

画面上ですべてを使用する方法

ここで、プレゼンテーションレベルに移動して、スクリーンプレゼンターがこのインタラクターとどのように対話するかを確認する価値があります。

私たちの機能は、フラグメントのスタックを内部に持つアクティビティです。

アプリケーションの送信が成功すると、別のアクティビティが開き、送信の成功についてユーザーに通知されます。メインアクティビティは、インタラクターのコマンドに応じて、目的のフラグメントを表示し、ツールバーですでに実行されたステップ数を表示する役割を果たします。これを行うには、ルートアクティビティプレゼンターで、インタラクターからサブジェクトをサブスクライブし、スタック内のフラグメントを切り替えるためのロジックを実装します。

progressInteractor.stepChangeObservable.subscribe { stepData ->
    if (stepData.position > currentPosition) {
        //      FragmentManager
    } else {
        //   
    }
    //   -    
}

各フラグメントのプレゼンターで、画面の開始時に、インタラクターに入力データを提供するように依頼します。前述のように、受信データはネットワークからのダウンロードに関連付けることができるため、受信データを別のストリームに転送することをお勧めします。

たとえば、教育情報を入力するための画面を見てみましょう。

progressInteractor.getDataForStep(EducationStep)
    .filter<ApplicationStepData.EducationStepData>()
    .subscribeOn(Schedulers.io())
    .subscribe { 
        val educationType = it.stepInData.educationType
 // todo:         

 it.stepOutData?.education?.let {
       // todo:      
  }
    }

「教育について」のステップを完了し、ユーザーがさらに進んでいきたいとします。出力を使用してオブジェクトを形成し、それをインタラクターに渡すだけです。

progressInteractor.completeStep(EducationStepOutData(education)).subscribe {
                   //     ( )
               }

インタラクターはデータ自体を保存し、必要に応じてスクリプトの変更を開始し、ルートアクティビティに次のステップに切り替えるように通知します。したがって、フラグメントはスクリプト内での位置について何も知りません。たとえば、機能の設計が変更された場合、フラグメントは簡単に再配置できます。

最後のフラグメントでは、データの保存が成功したことへの反応として、最後のリクエストの送信を追加します。覚えているようsendApplication()に、インタラクターでこのためのメソッドを作成しました。

progressInteractor.sendApplication()
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(
                {
                    //    
                    activityNavigator.start(ThankYouRoute())
                },
                {
                    //  
                }
            )

アプリケーションが正常に送信されたという情報が表示された最後の画面で、インタラクターをクリアして、プロセスを最初から再開できるようにします。

progressInteractor.closeProgressFeature()

それで全部です。5つの画面で構成される機能があります。「教育について」の画面はスキップでき、仕事の経験を記入した画面は、エッセイを書くための画面に置き換えられます。任意のステップで入力を中断して後で続行でき、入力したものはすべてドラフトに保存されます。プロジェクトでこのアプローチを最初に実装した著者である

VasyaBeglyanin @ icebailに特に感謝します。また、Misha Zinchenko @ midery-ドラフトアーキテクチャを最終バージョンにするためのヘルプ（この記事で説明）。

モバイルアプリに入力する増分データを設計する方法

明らかな解決策

より良くする方法

基本エンティティ

手順の説明

スクリプトに従って行動します

Interactorのしくみ

画面上ですべてを使用する方法

More articles: