---
title: "ペイウォールにインタラクティブな体重目標チャートを表示する"
description: "ペイウォールフローでユーザーごとの予測体重をチャートとして表示します。ユーザーはチャート上をドラッグして任意の週の体重を確認できます。"
---

> **AI agents**: to search Adapty docs faster and with fewer tokens, install the Adapty skills: `npx adapty skills install --yes`

カスタムエレメントを使ったペイウォールフローで、各ユーザーの予測体重をチャートとして表示するには、次の手順に従います。ユーザーはオンボーディングフローで現在の体重と目標体重を入力します。アプリは両方の値を収集します。チャートは、アプリを使って一方の値からもう一方の値へと毎週どれだけ進捗するかを示します。アプリはチャートをネイティブビューとして[カスタムエレメント](flow-custom-elements)でレンダリングします。このビューはチャートライブラリを使わずにチャートを描画します。

## 始める前に \{#before-you-start\}

<Tabs groupId="current-os" queryString>
<TabItem value="kotlin" label="Kotlin" default>

- アプリを Adapty Android SDK 4.4 以降にアップデートしてください。それより古い SDK バージョンでは、すべてのカスタム要素に[フォールバックコンテンツ](flow-custom-elements#set-fallback-content)が表示されます。
- アプリでフローを[取得](android-get-pb-paywalls)および[表示](android-present-paywalls)できるよう設定してください。
- アプリモジュールに Jetpack Compose をセットアップしてください。このレシピのチャートはコンポーザブルです。
- Gradle を使って `androidx.compose.foundation:foundation` から Compose Foundation をアプリに追加してください。

</TabItem>
<TabItem value="java" label="Java">

- アプリを Adapty Android SDK 4.4 以降にアップデートしてください。それより古い SDK バージョンでは、すべてのカスタム要素に[フォールバックコンテンツ](flow-custom-elements#set-fallback-content)が表示されます。
- アプリでフローを[取得](android-get-pb-paywalls)および[表示](android-present-paywalls)できるよう設定してください。

</TabItem>
</Tabs>

2つの別々のフローを作成します。1つはオンボーディング用、もう1つはペイウォール用です。それぞれを[プレースメント](placements)に追加してください。このレシピのコードは、ID `weight_paywall` のプレースメントからペイウォールフローを取得します。

## 1. オンボーディングフローで現在の体重と目標体重を聞く \{#1-ask-for-the-current-and-goal-weight-in-the-onboarding-flow\}

フロー & ペイウォールビルダーで、オンボーディングフローに2つの[**Number** 入力](builder-inputs-and-forms)を追加してください：

- 現在の体重（キログラム）用（**Element ID** は `weight`）
- 目標体重（キログラム）用（**Element ID** は `goal_weight`）

すべてのロケールで体重を同じように読み取れるようにするには、両方の入力の **Format** ドロップダウンから **Integer** を選択してください。入力はユーザーが入力した通りのテキストとして値をアプリに送信します。このレシピのコードでは "70.5" と "70,5" は異なる値として扱われます。整数には小数点区切り文字がありません。

アプリが両方の値を確実に受け取れるようにするには、オンボーディングフローの最後に入力のない画面を配置してください。その画面に [**Close flow**](onboarding-actions#close-flow) アクションを持つボタンを追加します。入力はフォーカスが外れたとき、またはユーザーが別の画面に移動したときに値を送信します。

## 2. ペイウォール画面にカスタム要素を追加する \{#2-add-the-custom-element-to-the-paywall-screen\}

ペイウォールフローで、画面に[カスタム要素を追加](flow-custom-elements#add-and-configure)して、チャート用に設定します：

- **Type**: `line_chart`
- **ID**: `weight_goal`
- **Height**: デフォルトの **Fixed** 高さを維持します。チャートはカスタム要素全体に広がります。

カスタム要素は、カルーセルなどのタッチに反応するコンテナの外に配置してください。これにより、ドラッグ操作にはチャートのみが反応します。

カスタム要素の内部に、サンプルの体重チャートを含む[**Image**](custom-media#image)を追加します。お使いのアプリのバージョンがチャートを表示できない場合、ユーザーにはこれが[フォールバック](flow-custom-elements#set-fallback-content)として表示されます。

## 3. アプリに現在の体重と目標体重を保存する \{#3-save-the-current-and-goal-weight-in-your-app\}

オンボーディングフローの `flow_user_input` イベントから現在の体重と目標体重を収集します（[フローからのデータ処理](android-flow-input)を参照）。ユーザーが最後の画面に到達したことを把握するには、`is_last_screen` が `true` に設定された `flow_screen_showed` イベントを監視してください。その画面の後にオンボーディングフローが閉じたら、両方の体重を `showWeightPaywall`（[ペイウォールフローをカスタム要素に合わせて開く](#5-match-the-chart-to-the-custom-element)関数）に渡してください。

<Tabs groupId="current-os" queryString>
<TabItem value="kotlin" label="Kotlin" default>

```kotlin showLineNumbers title="Kotlin"

class WeightOnboardingListener(
    private val activity: Activity, // the activity that displays the paywall flow
) : AdaptyFlowDefaultEventListener() {

    private val enteredWeights = mutableMapOf<String, String>()
    private var reachedLastScreen = false

    override fun onAnalyticEvent(
        name: String,
        params: Map<String, Any?>,
        context: Context,
    ) {
        if (name == "flow_screen_showed" && params["is_last_screen"] == true) {
            reachedLastScreen = true
            return
        }
        if (name != "flow_user_input") return

        val elementId = params["element_id"] as? String ?: return
        val value = params["value"] as? String ?: return

        enteredWeights[elementId] = value
    }

    override fun onActionPerformed(action: AdaptyUI.Action, context: Context) {
        // number inputs send their values as strings
        val currentWeight = enteredWeights["weight"]?.toDoubleOrNull()
        val goalWeight = enteredWeights["goal_weight"]?.toDoubleOrNull()

        if (action == AdaptyUI.Action.Close && reachedLastScreen &&
            currentWeight != null && goalWeight != null
        ) {
            // on the last screen, open the paywall flow in place of the onboarding flow
            showWeightPaywall(activity, currentWeight, goalWeight)
        } else {
            super.onActionPerformed(action, context) // the default handling, such as going back
        }
    }
}
```

オンボーディングフローの場合、`AdaptyUI.getFlowView` の `eventListener` パラメーターに `WeightOnboardingListener` を渡してください。リスナーは、ペイウォールフローを表示するアクティビティとともに作成します。

Jetpack Compose では、代わりにリスナーを `AdaptyFlowScreen` に渡し、2つ目の `AdaptyFlowScreen` でペイウォールフローを表示してください。

</TabItem>
<TabItem value="java" label="Java">

```java showLineNumbers title="Java"

public class WeightOnboardingListener extends AdaptyFlowDefaultEventListener {
    private final Activity activity; // the activity that displays the paywall flow
    private final Map<String, String> enteredWeights = new HashMap<>();
    private boolean reachedLastScreen = false;

    public WeightOnboardingListener(Activity activity) {
        this.activity = activity;
    }

    @Override
    public void onAnalyticEvent(String name, Map<String, ?> params, Context context) {
        if (name.equals("flow_screen_showed") && Boolean.TRUE.equals(params.get("is_last_screen"))) {
            reachedLastScreen = true;
            return;
        }
        if (!name.equals("flow_user_input")) return;

        Object elementId = params.get("element_id");
        Object value = params.get("value");
        if (elementId instanceof String && value instanceof String) {
            enteredWeights.put((String) elementId, (String) value);
        }
    }

    @Override
    public void onActionPerformed(AdaptyUI.Action action, Context context) {
        // number inputs send their values as strings
        Double currentWeight = parseWeight(enteredWeights.get("weight"));
        Double goalWeight = parseWeight(enteredWeights.get("goal_weight"));

        if (action instanceof AdaptyUI.Action.Close && reachedLastScreen
                && currentWeight != null && goalWeight != null) {
            // on the last screen, open the paywall flow in place of the onboarding flow
            WeightPaywall.showWeightPaywall(activity, currentWeight, goalWeight);
        } else {
            super.onActionPerformed(action, context); // the default handling, such as going back
        }
    }

    private static Double parseWeight(String value) {
        if (value == null) return null;
        try {
            return Double.parseDouble(value);
        } catch (NumberFormatException e) {
            return null;
        }
    }
}
```

オンボーディングフローの場合は、`AdaptyUI.getFlowView` の `eventListener` パラメーターに `WeightOnboardingListener` を渡してください。リスナーは、ペイウォールフローを表示するアクティビティを使用して作成します。

</TabItem>
</Tabs>

最後の画面でユーザーが [**Close flow** アクション](android-handle-paywall-actions#close-flows-and-paywalls)付きのボタンをタップすると、リスナーはオンボーディングフローの代わりにペイウォールフローを開きます。

## 4. チャートビューを作成する \{#create-the-chart-view\}

体重プランのモデルと、チャートを含むビューを作成します。このプランには、現在の体重から目標体重まで1週間ごとのエントリーが含まれています。ユーザーがチャート上をドラッグすると、タッチポイントの週がマークされ、その週の予測体重が表示されます。

<Tabs groupId="current-os" queryString>
<TabItem value="kotlin" label="Kotlin" default>

```kotlin showLineNumbers title="Kotlin"

class WeightPlan(currentWeight: Double, goalWeight: Double) {
    // one entry per week, from the current weight to the goal weight
    val entries: List<WeightEntry> = run {
        val weeklyChange = 0.5 // kg per week
        val start = System.currentTimeMillis()
        val weekMillis = 7L * 24 * 60 * 60 * 1000
        val weeks = ceil(abs(goalWeight - currentWeight) / weeklyChange).toInt()
        val step = if (goalWeight < currentWeight) -weeklyChange else weeklyChange
        (0..weeks).map { week ->
            val kilograms = if (week == weeks) goalWeight else currentWeight + step * week
            WeightEntry(Date(start + week * weekMillis), kilograms)
        }
    }
}

data class WeightEntry(val date: Date, val kilograms: Double)

@Composable
fun WeightGoalChart(entries: List<WeightEntry>) {
    // the week under the finger, or null when the user isn't dragging
    var selectedIndex by remember { mutableStateOf<Int?>(null) }
    val textMeasurer = rememberTextMeasurer()
    val dateFormat = remember { DateFormat.getDateInstance(DateFormat.MEDIUM) }
    val color = Color(0xFFAF52DE)
    val textStyle = TextStyle(color = Color.Gray, fontSize = 12.sp)
    val minKg = entries.minOf { it.kilograms }
    val kgRange = (entries.maxOf { it.kilograms } - minKg).coerceAtLeast(1.0)

    Canvas(
        Modifier
            .fillMaxSize()
            .pointerInput(entries) {
                // horizontal drags select a week; vertical drags scroll the screen
                detectHorizontalDragGestures(
                    onDragEnd = { selectedIndex = null },
                    onDragCancel = { selectedIndex = null },
                ) { change, _ ->
                    val index = (change.position.x / size.width * entries.lastIndex).roundToInt()
                    selectedIndex = index.coerceIn(0, entries.lastIndex)
                }
            }
    ) {
        val startDate = textMeasurer.measure(dateFormat.format(entries.first().date), textStyle)
        val endDate = textMeasurer.measure(dateFormat.format(entries.last().date), textStyle)
        val dateY = size.height - startDate.size.height
        val top = 24.dp.toPx() // room for the projected weight above the line
        val bottom = dateY - 8.dp.toPx()
        fun pointOf(index: Int) = Offset(
            x = size.width * index / entries.lastIndex.coerceAtLeast(1),
            y = bottom - ((entries[index].kilograms - minKg) / kgRange * (bottom - top)).toFloat(),
        )

        // the line from the current weight to the goal weight
        for (index in 1..entries.lastIndex) {
            drawLine(color, pointOf(index - 1), pointOf(index), strokeWidth = 2.dp.toPx())
        }
        // the dates of the first and the last week
        drawText(startDate, topLeft = Offset(0f, dateY))
        drawText(endDate, topLeft = Offset(size.width - endDate.size.width, dateY))

        // the selected week: a point, and the projected weight above it
        selectedIndex?.let { index ->
            val point = pointOf(index)
            drawCircle(color, radius = 5.dp.toPx(), center = point)
            val weight = String.format(Locale.getDefault(), "%.1f kg", entries[index].kilograms)
            val label = textMeasurer.measure(weight, textStyle.copy(color = color))
            val x = (point.x - label.size.width / 2)
                .coerceAtMost(size.width - label.size.width)
                .coerceAtLeast(0f)
            drawText(label, topLeft = Offset(x, point.y - label.size.height - 8.dp.toPx()))
        }
    }
}
```

</TabItem>
<TabItem value="java" label="Java">

```java showLineNumbers title="Java"

public class WeightPlan {
    // one entry per week, from the current weight to the goal weight
    public final List<WeightEntry> entries = new ArrayList<>();

    public WeightPlan(double currentWeight, double goalWeight) {
        double weeklyChange = 0.5; // kg per week
        long start = System.currentTimeMillis();
        long weekMillis = 7L * 24 * 60 * 60 * 1000;
        int weeks = (int) Math.ceil(Math.abs(goalWeight - currentWeight) / weeklyChange);
        double step = goalWeight < currentWeight ? -weeklyChange : weeklyChange;
        for (int week = 0; week <= weeks; week++) {
            double kilograms = week == weeks ? goalWeight : currentWeight + step * week;
            entries.add(new WeightEntry(new Date(start + week * weekMillis), kilograms));
        }
    }
}

public class WeightEntry {
    public final Date date;
    public final double kilograms;

    public WeightEntry(Date date, double kilograms) {
        this.date = date;
        this.kilograms = kilograms;
    }
}

public class WeightGoalChartView extends View {
    private final List<WeightEntry> entries;
    private final DateFormat dateFormat = DateFormat.getDateInstance(DateFormat.MEDIUM);
    private final Paint chartPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
    private final Paint datePaint = new Paint(Paint.ANTI_ALIAS_FLAG);
    private final float density = getResources().getDisplayMetrics().density;
    private final int touchSlop;
    private double minKg = Double.MAX_VALUE;
    private double maxKg = -Double.MAX_VALUE;
    private float downX;
    private float downY;
    // the week under the finger, or -1 when the user isn't dragging
    private int selectedIndex = -1;

    public WeightGoalChartView(Context context, List<WeightEntry> entries) {
        super(context);
        this.entries = entries;
        touchSlop = ViewConfiguration.get(context).getScaledTouchSlop();
        float textSize = TypedValue.applyDimension(
                TypedValue.COMPLEX_UNIT_SP, 12, getResources().getDisplayMetrics());
        chartPaint.setColor(0xFFAF52DE);
        chartPaint.setStrokeWidth(2 * density);
        chartPaint.setTextSize(textSize);
        datePaint.setColor(Color.GRAY);
        datePaint.setTextSize(textSize);
        for (WeightEntry entry : entries) {
            minKg = Math.min(minKg, entry.kilograms);
            maxKg = Math.max(maxKg, entry.kilograms);
        }
    }

    @Override
    protected void onDraw(Canvas canvas) {
        // the line from the current weight to the goal weight
        for (int index = 1; index < entries.size(); index++) {
            canvas.drawLine(xOf(index - 1), yOf(index - 1), xOf(index), yOf(index), chartPaint);
        }
        // the dates of the first and the last week
        String endDate = dateFormat.format(entries.get(entries.size() - 1).date);
        float dateY = getHeight() - datePaint.descent();
        canvas.drawText(dateFormat.format(entries.get(0).date), 0, dateY, datePaint);
        canvas.drawText(endDate, getWidth() - datePaint.measureText(endDate), dateY, datePaint);

        // the selected week: a point, and the projected weight above it
        if (selectedIndex >= 0) {
            float x = xOf(selectedIndex);
            float y = yOf(selectedIndex);
            canvas.drawCircle(x, y, 5 * density, chartPaint);
            double kilograms = entries.get(selectedIndex).kilograms;
            String weight = String.format(Locale.getDefault(), "%.1f kg", kilograms);
            float width = chartPaint.measureText(weight);
            float labelX = Math.max(0, Math.min(x - width / 2, getWidth() - width));
            canvas.drawText(weight, labelX, y - 8 * density, chartPaint);
        }
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        switch (event.getActionMasked()) {
            case MotionEvent.ACTION_DOWN:
                downX = event.getX();
                downY = event.getY();
                return true;
            case MotionEvent.ACTION_MOVE:
                // horizontal drags select a week; vertical drags scroll the screen
                float dx = Math.abs(event.getX() - downX);
                if (selectedIndex < 0 && (dx < touchSlop || dx < Math.abs(event.getY() - downY))) {
                    return true;
                }
                getParent().requestDisallowInterceptTouchEvent(true);
                int index = Math.round(event.getX() / getWidth() * (entries.size() - 1));
                selectedIndex = Math.max(0, Math.min(index, entries.size() - 1));
                invalidate();
                return true;
            case MotionEvent.ACTION_UP:
            case MotionEvent.ACTION_CANCEL:
                selectedIndex = -1;
                invalidate();
                return true;
        }
        return super.onTouchEvent(event);
    }

    private float xOf(int index) {
        return getWidth() * index / (float) Math.max(entries.size() - 1, 1);
    }

    private float yOf(int index) {
        float top = 24 * density; // room for the projected weight above the line
        float bottom = getHeight() - datePaint.getFontSpacing() - 8 * density; // room for the dates
        double fraction = (entries.get(index).kilograms - minKg) / Math.max(maxKg - minKg, 1);
        return (float) (bottom - fraction * (bottom - top));
    }
}
```

</TabItem>
</Tabs>

このプランでは、体重が1週間に0.5 kgずつ変化することを前提としています。別の変化率を使用するには、`weeklyChange` を編集してください。

## 5. カスタム要素とチャートを対応付ける \{#5-match-the-chart-to-the-custom-element\}

`line_chart` タイプおよび `weight_goal` IDに対してチャートビューを返す[リゾルバー](android-flow-custom-elements#write-a-resolver-to-match-custom-elements-and-views)を記述します。ウェイトプランはリゾルバーのプロパティに保存します：

<Tabs groupId="current-os" queryString>
<TabItem value="kotlin" label="Kotlin" default>

```kotlin showLineNumbers title="Kotlin"

class WeightChartResolver(
    private val plan: WeightPlan,
) : AdaptyCustomElementsResolver {

    override fun resolve(type: String, id: String): AdaptyCustomElementContent? =
        if (type == "line_chart" && id == "weight_goal") {
            AdaptyCustomElementContent.compose { WeightGoalChart(plan.entries) }
        } else {
            null // another custom element: show the fallback
        }
}
```

</TabItem>
<TabItem value="java" label="Java">

```java showLineNumbers title="Java"

public class WeightChartResolver implements AdaptyCustomElementsResolver {
    private final WeightPlan plan;

    public WeightChartResolver(WeightPlan plan) {
        this.plan = plan;
    }

    @Override
    public AdaptyCustomElementContent resolve(String type, String id) {
        if (type.equals("line_chart") && id.equals("weight_goal")) {
            return AdaptyCustomElementContent.view(
                    (context, elementContext) -> new WeightGoalChartView(context, plan.entries)
            );
        }
        return null; // another custom element: show the fallback
    }
}
```

</TabItem>
</Tabs>

ペイウォールフローのビューを作成する際に、リゾルバーをアタッチします。現在の体重と目標体重からウェイトプランを使って、リゾルバーを作成します。

<Tabs groupId="current-os" queryString>
<TabItem value="kotlin" label="Kotlin" default>

```kotlin showLineNumbers title="Kotlin"

fun showWeightPaywall(activity: Activity, currentWeight: Double, goalWeight: Double) {
    val plan = WeightPlan(currentWeight, goalWeight)
    Adapty.getFlow("weight_paywall") { flowResult ->
        if (flowResult !is AdaptyResult.Success) return@getFlow // handle the error
        AdaptyUI.getFlowConfiguration(flowResult.value) { configResult ->
            if (configResult !is AdaptyResult.Success) return@getFlowConfiguration // handle the error
            val flowView = AdaptyUI.getFlowView(
                activity,
                configResult.value,
                products = null,
                eventListener = AdaptyFlowDefaultEventListener(),
                customElementsResolver = WeightChartResolver(plan),
            )
            activity.setContentView(flowView) // in place of the onboarding flow
        }
    }
}
```

</TabItem>
<TabItem value="java" label="Java">

```java showLineNumbers title="Java"

public class WeightPaywall {
    public static void showWeightPaywall(Activity activity, double currentWeight, double goalWeight) {
        WeightPlan plan = new WeightPlan(currentWeight, goalWeight);
        Adapty.getFlow("weight_paywall", flowResult -> {
            if (!(flowResult instanceof AdaptyResult.Success)) return; // handle the error
            AdaptyFlow flow = ((AdaptyResult.Success<AdaptyFlow>) flowResult).getValue();
            AdaptyUI.getFlowConfiguration(flow, configResult -> {
                if (!(configResult instanceof AdaptyResult.Success)) return; // handle the error
                AdaptyFlowView flowView = AdaptyUI.getFlowView(
                        activity,
                        ((AdaptyResult.Success<AdaptyUI.FlowConfiguration>) configResult).getValue(),
                        null, // products
                        new AdaptyFlowDefaultEventListener(),
                        // defaults: if your app passes other values here, keep them
                        AdaptyFlowInsets.Unspecified,
                        AdaptyCustomAssets.Empty,
                        AdaptyUiTagResolver.Default,
                        AdaptyUiTimerResolver.Default,
                        null, // observerModeHandler
                        new WeightChartResolver(plan)
                );
                activity.setContentView(flowView); // in place of the onboarding flow
            });
        });
    }
}
```

</TabItem>
</Tabs>

アプリに[アプリ全体のリゾルバー](android-flow-custom-elements#display-views-in-every-flow)が設定されている場合、このリゾルバーはペイウォールフローでそれを置き換えます。`WeightChartResolver` は他の Type および ID に対してはビューを返しません。このレシピのペイウォールフローには他のカスタム要素がないためです。ペイウォールフローに他のカスタム要素がある場合は、アプリ全体のリゾルバーをこのリゾルバーに渡してください。その後、[1つのフローにデータを表示する](android-flow-custom-elements#display-data-for-one-flow)の説明に従って、それらの Type および ID に対してアプリ全体のリゾルバーを呼び出します。

## 6. デバイスでテストする \{#6-test-on-a-device\}

フロービルダー & ペイウォールビルダーはアプリのコードを実行できないため、キャンバスにはフォールバックのみ表示されます。チャートをプレビューするには:

1. [両方のフローを公開します](builder-save-publish)。キャッシュではなく最新の公開バージョンを確認するには、デバイスを[テストデバイス](test-devices)として登録してください。
2. リゾルバーを含むアプリのビルドを実行します。現在の体重と目標体重を入力してオンボーディングフローを完了します。チャートのラインが現在の体重から始まり、目標体重で終わることを確認してください。
3. チャート上をドラッグして、指の下にある週の予測体重がライン上に表示されることを確認してください。

フォールバックをテストするには、`WeightChartResolver` が `null` を返すようにして、ペイウォールフローを再度開いてください。

フォールバックが表示される理由を調べるには、Androidガイドの[デバイスでテストする](android-flow-custom-elements#test-on-a-device)セクションの手順に従ってください。