在产品场景中提供事件

关于产品流程的文档，包含SDK集成示例：

关于该方法的更多信息

产品流程 是一种处理应用中标准 AppMetrica 事件的新方案，适用于包含优惠、购买、申请以及多步骤产品和服务订购场景的应用。

这种方法有助于为以下实体和场景标准化分析：

  • product offers;
  • marketing offers;
  • 购买商品和服务；
  • user funnels;
  • ordering steps;
  • 应用程序和审批结果；
  • 异步 S2S 结果。

我们建议为以下类型的应用使用产品流程（Product Flow）方法：

  • banks;
  • 保险服务；
  • telecom apps;
  • 预订和旅行服务；
  • subscription services;
  • 送货服务；
  • marketplaces;
  • 游戏应用；
  • 任何具有产品场景、购买和漏斗分析的应用。

不消耗自定义事件和DSA限制

新的标准事件不计入以下限制：

  • 自定义事件;
  • 数据流 API.

这让您可以：

  • 逐步采用新的标记方案；
  • 发送更多产品场景和步骤；
  • 在不消耗自定义事件和 DSA 限额的情况下，构建详细的漏斗和分析。

这种方法解决什么问题

目前，许多应用使用自定义事件来发送关于以下实体和场景的分析数据：

  • offers;
  • applications;
  • product scenarios;
  • onboarding scenarios;
  • 订单下单场景;
  • approval scenarios.

这种方法会导致以下问题：

  • 相同的场景标记方式不同；
  • 创建标准报告很困难；
  • 分析数据在团队间传递较为困难；
  • 自动漏斗构建是不可能的；
  • 很难比较广告推送和场景的效果。

产品场景和奖励事件架构提供了一种统一的方法来标注关键阶段：

  • offer display;
  • 开始订购;
  • 中间步骤；
  • 最终结果。

主要事件

交互方案基于四个主要事件：

事件

含义

offerShown

用户看到了一个倡议或提议

flowStart

用户开始订购产品

flowStep

一个中间排序步骤

flowResult

最终结果

标记场景

此部分展示了不同行业的完整用户场景。

场景示例

本文档中的所有场景都是示例标记，展示了可能的集成选项。

事件名称、参数、场景步骤和负载结构可以根据您的应用和用户场景特点进行调整。

每个场景描述：

  • 用户在应用中看到和做的事情；
  • 哪些事件需要发送；
  • when offerShown 可以省略；
  • when flowStart 可以省略；
  • 如何通过 flowStep 传递中间步骤;
  • 如何通过flowResult传递最终结果；
  • 如何使用 payload、referrer 和 stepOption；
  • 如何后续通过 S2S 传递结果。

银行和金融科技

通过个人优惠贷款：优惠 → 申请 → 待处理 → S2S 结果

用户看到一个广告栏：“您已预批准贷款额度最高为 500,000 卢布，利率从 12.5% 开始”。
AppMetrica.reportEvent(
    ProductFlowEvent.offerShown("credit_q1", "financial_product")
        .withProductId("personal_loan")
        .withBenefitType("discount_percentage")
        .withReferrer(
                OfferReferrer.newBuilder()
                    .withType("banner")
                    .withIdentifier("main_screen_credit_banner")
                    .withScreen("main")
                    .build()
        )
        .withPayload(mapOf(
            "campaign_id" to "credit_spring_2026",
            "segment" to "preapproved_users",
            "approved_limit" to "500000",
            "currency" to "RUB",
            "interest_rate" to "12.5"
        ))
        .build()
)

let event = ProductFlowEvents.offerShown(productOfferId: "credit_q1", offerType: "financial_product")
    .withProductId("personal_loan")
    .withBenefitType("discount_percentage")
    .withReferrer(OfferReferrer(type: "banner", identifier: "main_screen_credit_banner", screen: "main"))
    .withPayload([
        "campaign_id": "credit_spring_2026",
        "segment": "preapproved_users",
        "approved_limit": "500000",
        "currency": "RUB",
        "interest_rate": "12.5"
    ])
    .build()

AppMetrica.report(event: event)
用户点击广告牌并开始填写申请表。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStart("personal_loan")
        .withProductOfferId("credit_q1")
        .build()
)

let event = ProductFlowEvents.flowStart(productId: "personal_loan")
    .withProductOfferId("credit_q1")
    .build()

AppMetrica.report(event: event)
用户上传文档。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("personal_loan", "documents")
        .withProductOfferId("credit_q1")
        .withStepOption("passport_upload")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "personal_loan", stepType: "documents")
    .withProductOfferId("credit_q1")
    .withStepOption("passport_upload")
    .build()

AppMetrica.report(event: event)
用户提交申请以进行评分。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("personal_loan", "scoring")
        .withProductOfferId("credit_q1")
        .withStepOption("automatic_scoring")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "personal_loan", stepType: "scoring")
    .withProductOfferId("credit_q1")
    .withStepOption("automatic_scoring")
    .build()

AppMetrica.report(event: event)
用户已完成自己的部分，应用程序正在审核中。
AppMetrica.reportEvent(
    ProductFlowEvent.flowResultForProduct(ProductFlowStatus.PENDING, "personal_loan")
        .withProductOfferId("credit_q1")
        .withPayload(mapOf(
            "application_id" to "loan_app_12345",
            "requested_amount" to "450000",
            "currency" to "RUB"
        ))
        .build()
)

let event = ProductFlowEvents.flowResult(productId: "personal_loan", status: .pending)
    .withProductOfferId("credit_q1")
    .withPayload([
        "application_id": "loan_app_12345",
        "requested_amount": "450000",
        "currency": "RUB"
    ])
    .build()

AppMetrica.report(event: event)
之后，银行通过 S2S 发送最终结果。
flowResult(
    productId = "travel_insurance",
    productOfferId = "travel_insurance_offer",
    status = "success",
    payload = mapOf(
        "application_id" to "insurance_app_987",
        "policy_id" to "policy_555",
        "decision_source" to "s2s"
    )
)

通过S2S方案发送推送事件将在未来的一个版本中通过POST API实现。 当前文档提供了一个示例脚本，演示了预期的集成方法。

无借款提议的自然申请

用户自行从应用菜单打开了“贷款”部分。 没有提供任何优惠。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStart("personal_loan")
        .build()
)

let event = ProductFlowEvents.flowStart(productId: "personal_loan")
    .build()

AppMetrica.report(event: event)
用户上传文档。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("personal_loan", "documents")
        .withStepOption("passport_upload")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "personal_loan", stepType: "documents")
    .withStepOption("passport_upload")
    .build()

AppMetrica.report(event: event)
应用程序已提交审核。
AppMetrica.reportEvent(
    ProductFlowEvent.flowResultForProduct(ProductFlowStatus.PENDING, "personal_loan")
        .withPayload(mapOf(
            "application_id" to "loan_app_67890",
            "requested_amount" to "300000",
            "currency" to "RUB"
        ))
        .build()
)

let event = ProductFlowEvents.flowResult(productId: "personal_loan", status: .pending)
    .withPayload([
        "application_id": "loan_app_67890",
        "requested_amount": "300000",
        "currency": "RUB"
    ])
    .build()

AppMetrica.report(event: event)
后来，银行通过S2S发送拒绝。
flowResult(
    产品ID = "personal_loan",
    产品报价ID = null,
    状态 = "已拒绝",
    负载 = 映射为(
        "申请编号" to "loan_app_67890",
        "拒绝原因" to "scoring_rejected",
        "决策来源" to "s2s"
    )
)

通过S2S方案发送推广事件将在未来的某个版本中通过POST API实现。 当前文档提供了一个示例脚本，演示了预期的集成方法。

Telecom

eSIM 通过优惠激活

用户打开资费页面并看到横幅：“eSIM 首月享 20% 折扣”。
AppMetrica.reportEvent(
    ProductFlowEvent.offerShown("esim_offer_q2", "service")
        .withProductId("esim")
        .withBenefitType("discount_percentage")
        .withReferrer(
                OfferReferrer.newBuilder()
                    .withType("banner")
                    .withIdentifier("tariffs_screen_esim_banner")
                    .withScreen("tariffs")
                    .build()
        )
        .withPayload(mapOf(
            "campaign_id" to "esim_discount_q2",
            "discount_value" to "20",
            "discount_period" to "first_month",
            "region" to "RS"
        ))
        .build()
)

let event = ProductFlowEvents.offerShown(productOfferId: "esim_offer_q2", offerType: "service")
    .withProductId("esim")
    .withBenefitType("discount_percentage")
    .withReferrer(OfferReferrer(type: "banner", identifier: "tariffs_screen_esim_banner", screen: "tariffs"))
    .withPayload([
        "campaign_id": "esim_discount_q2",
        "discount_value": "20",
        "discount_period": "first_month",
        "region": "RS"
    ])
    .build()

AppMetrica.report(event: event)
用户点击广告牌并开始激活。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStart("esim")
        .withProductOfferId("esim_offer_q2")
        .build()
)

let event = ProductFlowEvents.flowStart(productId: "esim")
    .withProductOfferId("esim_offer_q2")
    .build()

AppMetrica.report(event: event)
用户选择一个套餐。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("esim", "tariff_selection")
        .withProductOfferId("esim_offer_q2")
        .withStepOption("unlimited_30d")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "esim", stepType: "tariff_selection")
    .withProductOfferId("esim_offer_q2")
    .withStepOption("unlimited_30d")
    .build()

AppMetrica.report(event: event)
用户正在进行身份验证。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("esim", "identity_verification")
        .withProductOfferId("esim_offer_q2")
        .withStepOption("document_scan")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "esim", stepType: "identity_verification")
    .withProductOfferId("esim_offer_q2")
    .withStepOption("document_scan")
    .build()

AppMetrica.report(event: event)
eSIM已成功激活。
AppMetrica.reportEvent(
    ProductFlowEvent.flowResultForProduct(ProductFlowStatus.SUCCESS, "esim")
        .withProductOfferId("esim_offer_q2")
        .withPayload(mapOf(
            "tariff_id" to "unlimited_30d",
            "activation_type" to "esim",
            "discount_applied" to "true"
        ))
        .build()
)

let event = ProductFlowEvents.flowResult(productId: "esim", status: .success)
    .withProductOfferId("esim_offer_q2")
    .withPayload([
        "tariff_id": "unlimited_30d",
        "activation_type": "esim",
        "discount_applied": "true"
    ])
    .build()

AppMetrica.report(event: event)

出行前激活流量包

用户打开流动数据服务部分，看到一个优惠：“欧洲10 GB，14天，1500 RUB”。
AppMetrica.reportEvent(
    ProductFlowEvent.offerShown("eu_roaming_10gb", "service")
        .withProductId("roaming_package")
        .withReferrer(
                OfferReferrer.newBuilder()
                    .withType("banner")
                    .withIdentifier("roaming_europe_banner")
                    .withScreen("roaming")
                    .build()
        )
        .withPrice(OfferPrice(1500.0, "RUB"))
        .withPayload(mapOf(
            "region" to "Europe",
            "traffic_limit_gb" to "10",
            "duration_days" to "14"
        ))
        .build()
)

let event = ProductFlowEvents.offerShown(productOfferId: "eu_roaming_10gb", offerType: "service")
    .withProductId("roaming_package")
    .withReferrer(OfferReferrer(type: "banner", identifier: "roaming_europe_banner", screen: "roaming"))
    .withPrice(OfferPrice(amount: 1500.0, unit: "RUB"))
    .withPayload([
        "region": "Europe",
        "traffic_limit_gb": "10",
        "duration_days": "14"
    ])
    .build()

AppMetrica.report(event: event)
用户开始激活流量包。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStart("roaming_package")
        .withProductOfferId("eu_roaming_10gb")
        .build()
)

let event = ProductFlowEvents.flowStart(productId: "roaming_package")
    .withProductOfferId("eu_roaming_10gb")
    .build()

AppMetrica.report(event: event)
用户确认激活条款。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("roaming_package", "terms_confirmation")
        .withProductOfferId("eu_roaming_10gb")
        .withStepOption("accepted")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "roaming_package", stepType: "terms_confirmation")
    .withProductOfferId("eu_roaming_10gb")
    .withStepOption("accepted")
    .build()

AppMetrica.report(event: event)
漫游包已成功激活。
AppMetrica.reportEvent(
    ProductFlowEvent.flowResultForProduct(ProductFlowStatus.SUCCESS, "roaming_package")
        .withProductOfferId("eu_roaming_10gb")
        .withPayload(mapOf(
            "region" to "Europe",
            "traffic_limit_gb" to "10",
            "duration_days" to "14",
            "activation_status" to "enabled"
        ))
        .build()
)

let event = ProductFlowEvents.flowResult(productId: "roaming_package", status: .success)
    .withProductOfferId("eu_roaming_10gb")
    .withPayload([
        "region": "Europe",
        "traffic_limit_gb": "10",
        "duration_days": "14",
        "activation_status": "enabled"
    ])
    .build()

AppMetrica.report(event: event)

升级套餐

用户看到一个推荐：“升级到 Premium 套餐，享受无限流量互联网”。
AppMetrica.reportEvent(
    ProductFlowEvent.offerShown("premium_tariff_upgrade", "service")
        .withProductId("tariff_upgrade")
        .withBenefitType("bundle_extra")
        .withReferrer(
                OfferReferrer.newBuilder()
                    .withType("popup")
                    .withIdentifier("premium_upgrade_popup")
                    .withScreen("tariff_details")
                    .build()
        )
        .withPrice(OfferPrice(1990.0, "RUB"))
        .withPayload(mapOf(
            "current_tariff" to "smart_m",
            "target_tariff" to "premium_unlimited"
        ))
        .build()
)

let event = ProductFlowEvents.offerShown(productOfferId: "premium_tariff_upgrade", offerType: "service")
    .withProductId("tariff_upgrade")
    .withBenefitType("bundle_extra")
    .withReferrer(OfferReferrer(type: "popup", identifier: "premium_upgrade_popup", screen: "tariff_details"))
    .withPrice(OfferPrice(amount: 1990.0, unit: "RUB"))
    .withPayload([
        "current_tariff": "smart_m",
        "target_tariff": "premium_unlimited"
    ])
    .build()

AppMetrica.report(event: event)
用户开始修改套餐。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStart("tariff_upgrade")
        .withProductOfferId("premium_tariff_upgrade")
        .build()
)

let event = ProductFlowEvents.flowStart(productId: "tariff_upgrade")
    .withProductOfferId("premium_tariff_upgrade")
    .build()

AppMetrica.report(event: event)
用户确认新套餐。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("tariff_upgrade", "tariff_confirmation")
        .withProductOfferId("premium_tariff_upgrade")
        .withStepOption("premium_unlimited")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "tariff_upgrade", stepType: "tariff_confirmation")
    .withProductOfferId("premium_tariff_upgrade")
    .withStepOption("premium_unlimited")
    .build()

AppMetrica.report(event: event)
计费方案已成功更改。
AppMetrica.reportEvent(
    ProductFlowEvent.flowResultForProduct(ProductFlowStatus.SUCCESS, "tariff_upgrade")
        .withProductOfferId("premium_tariff_upgrade")
        .withPayload(mapOf(
            "previous_tariff" to "smart_m",
            "new_tariff" to "premium_unlimited",
            "upgrade_status" to "completed"
        ))
        .build()
)

let event = ProductFlowEvents.flowResult(productId: "tariff_upgrade", status: .success)
    .withProductOfferId("premium_tariff_upgrade")
    .withPayload([
        "previous_tariff": "smart_m",
        "new_tariff": "premium_unlimited",
        "upgrade_status": "completed"
    ])
    .build()

AppMetrica.report(event: event)

家庭互联网连接

用户打开“家庭网”部分，看到一个推荐：“家庭网500 Mbps，每月990 RUB”。
AppMetrica.reportEvent(
    ProductFlowEvent.offerShown("home_internet_500", "service")
        .withProductId("home_internet")
        .withReferrer(
                OfferReferrer.newBuilder()
                    .withType("banner")
                    .withIdentifier("home_internet_offer")
                    .withScreen("home_services")
                    .build()
        )
        .withPrice(OfferPrice(990.0, "RUB"))
        .withPayload(mapOf(
            "speed_mbps" to "500",
            "connection_fee" to "0"
        ))
        .build()
)

let event = ProductFlowEvents.offerShown(productOfferId: "home_internet_500", offerType: "service")
    .withProductId("home_internet")
    .withReferrer(OfferReferrer(type: "banner", identifier: "home_internet_offer", screen: "home_services"))
    .withPrice(OfferPrice(amount: 990.0, unit: "RUB"))
    .withPayload([
        "speed_mbps": "500",
        "connection_fee": "0"
    ])
    .build()

AppMetrica.report(event: event)
用户开始填写家庭网申请表。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStart("home_internet")
        .withProductOfferId("home_internet_500")
        .build()
)

let event = ProductFlowEvents.flowStart(productId: "home_internet")
    .withProductOfferId("home_internet_500")
    .build()

AppMetrica.report(event: event)
用户输入连接地址。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("home_internet", "address_input")
        .withProductOfferId("home_internet_500")
        .withStepOption("manual_input")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "home_internet", stepType: "address_input")
    .withProductOfferId("home_internet_500")
    .withStepOption("manual_input")
    .build()

AppMetrica.report(event: event)
用户选择技术人员访问日期。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("home_internet", "installation_timeslot")
        .withProductOfferId("home_internet_500")
        .withStepOption("2026-06-20_10:00")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "home_internet", stepType: "installation_timeslot")
    .withProductOfferId("home_internet_500")
    .withStepOption("2026-06-20_10:00")
    .build()

AppMetrica.report(event: event)
连接请求已提交，用户正等待技术人员到访。
AppMetrica.reportEvent(
    ProductFlowEvent.flowResultForProduct(ProductFlowStatus.PENDING, "home_internet")
        .withProductOfferId("home_internet_500")
        .withPayload(mapOf(
            "request_id" to "internet_request_555",
            "connection_status" to "awaiting_installation",
            "selected_timeslot" to "2026-06-20_10:00"
        ))
        .build()
)

let event = ProductFlowEvents.flowResult(productId: "home_internet", status: .pending)
    .withProductOfferId("home_internet_500")
    .withPayload([
        "request_id": "internet_request_555",
        "connection_status": "awaiting_installation",
        "selected_timeslot": "2026-06-20_10:00"
    ])
    .build()

AppMetrica.report(event: event)
之后，运营商通过 S2S 报告：技术人员已完成安装，互联网已连接，套餐已激活。
flowResult(
    productId = "home_internet",
    productOfferId = "home_internet_500",
    status = "成功",
    payload = mapOf(
        "request_id" to "internet_request_555",
        "installation_status" to "已完成",
        "technician_visit" to "已完成",
        "tariff_id" to "home_500",
        "tariff_status" to "活跃",
        "decision_source" to "s2s"
    )
)

通过S2S方案发送推广事件将在未来的某个版本中通过POST API实现。 当前文档提供了一个示例脚本，演示了预期的集成方法。

旅行 / 预订

预订酒店享折扣

用户在查找贝尔格莱德的酒店时看到一张卡片：“该酒店折扣20%”。
AppMetrica.reportEvent(
    ProductFlowEvent.offerShown("hotel_discount_may", "booking")
        .withProductId("hotel_booking")
        .withBenefitType("discount_percentage")
        .withReferrer(
                OfferReferrer.newBuilder()
                    .withType("banner")
                    .withIdentifier("search_results_hotel_discount")
                    .withScreen("hotel_search_results")
                    .build()
        )
        .withPrice(OfferPrice(20000.0, "RUB"))
        .withPayload(mapOf(
            "campaign_id" to "may_hotels_sale",
            "hotel_id" to "hotel_987",
            "city" to "Belgrade",
            "discount_value" to "20",
            "original_price" to "25000",
            "room_type" to "deluxe",
            "refundable" to "true"
        ))
        .build()
)

let event = ProductFlowEvents.offerShown(productOfferId: "hotel_discount_may", offerType: "booking")
    .withProductId("hotel_booking")
    .withBenefitType("discount_percentage")
    .withReferrer(OfferReferrer(type: "banner", identifier: "search_results_hotel_discount", screen: "hotel_search_results"))
    .withPrice(OfferPrice(amount: 20000.0, unit: "RUB"))
    .withPayload([
        "campaign_id": "may_hotels_sale",
        "hotel_id": "hotel_987",
        "city": "Belgrade",
        "discount_value": "20",
        "original_price": "25000",
        "room_type": "deluxe",
        "refundable": "true"
    ])
    .build()

AppMetrica.report(event: event)
用户开始预订。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStart("hotel_booking")
        .withProductOfferId("hotel_discount_may")
        .build()
)

let event = ProductFlowEvents.flowStart(productId: "hotel_booking")
    .withProductOfferId("hotel_discount_may")
    .build()

AppMetrica.report(event: event)
用户选择日期。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("hotel_booking", "dates")
        .withProductOfferId("hotel_discount_may")
        .withStepOption("3_nights")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "hotel_booking", stepType: "dates")
    .withProductOfferId("hotel_discount_may")
    .withStepOption("3_nights")
    .build()

AppMetrica.report(event: event)
用户选择嘉宾。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("hotel_booking", "guests")
        .withProductOfferId("hotel_discount_may")
        .withStepOption("2_adults")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "hotel_booking", stepType: "guests")
    .withProductOfferId("hotel_discount_may")
    .withStepOption("2_adults")
    .build()

AppMetrica.report(event: event)
用户选择支付方式。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("hotel_booking", "payment")
        .withProductOfferId("hotel_discount_may")
        .withStepOption("bank_card")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "hotel_booking", stepType: "payment")
    .withProductOfferId("hotel_discount_may")
    .withStepOption("bank_card")
    .build()

AppMetrica.report(event: event)
预约成功完成。
AppMetrica.reportEvent(
    ProductFlowEvent.flowResultForProduct(ProductFlowStatus.SUCCESS, "hotel_booking")
        .withProductOfferId("hotel_discount_may")
        .withPrice(OfferPrice(20000.0, "RUB"))
        .withPayload(mapOf(
            "hotel_id" to "hotel_987",
            "city" to "Belgrade",
            "nights" to "3",
            "guests" to "2",
            "original_price" to "25000",
            "discount_applied" to "true"
        ))
        .build()
)

let event = ProductFlowEvents.flowResult(productId: "hotel_booking", status: .success)
    .withProductOfferId("hotel_discount_may")
    .withPrice(OfferPrice(amount: 20000.0, unit: "RUB"))
    .withPayload([
        "hotel_id": "hotel_987",
        "city": "Belgrade",
        "nights": "3",
        "guests": "2",
        "original_price": "25000",
        "discount_applied": "true"
    ])
    .build()

AppMetrica.report(event: event)

医疗服务

自然排名的医生预约（无推荐）

用户自行从应用菜单打开医生预约部分。 没有提供任何优惠或促销方案。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStart("doctor_appointment")
        .withPayload(mapOf("entry_point" to "menu", "clinic_id" to "clinic_123"))
        .build()
)

let event = ProductFlowEvents.flowStart(productId: "doctor_appointment")
    .withPayload(["entry_point": "menu", "clinic_id": "clinic_123"])
    .build()

AppMetrica.report(event: event)
用户选择医生的专业。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("doctor_appointment", "specialization_selection")
        .withStepOption("therapy")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "doctor_appointment", stepType: "specialization_selection")
    .withStepOption("therapy")
    .build()

AppMetrica.report(event: event)
用户选择医生。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("doctor_appointment", "doctor_selection")
        .withStepOption("doctor_456")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "doctor_appointment", stepType: "doctor_selection")
    .withStepOption("doctor_456")
    .build()

AppMetrica.report(event: event)
用户选择预约日期和时间。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("doctor_appointment", "timeslot_selection")
        .withStepOption("2026-06-10_14:30")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "doctor_appointment", stepType: "timeslot_selection")
    .withStepOption("2026-06-10_14:30")
    .build()

AppMetrica.report(event: event)
预约医生成功创建。
AppMetrica.reportEvent(
    ProductFlowEvent.flowResultForProduct(ProductFlowStatus.SUCCESS, "doctor_appointment")
        .withPayload(mapOf(
            "appointment_id" to "appointment_777",
            "clinic_id" to "clinic_123",
            "doctor_specialization" to "therapy"
        ))
        .build()
)

let event = ProductFlowEvents.flowResult(productId: "doctor_appointment", status: .success)
    .withPayload([
        "appointment_id": "appointment_777",
        "clinic_id": "clinic_123",
        "doctor_specialization": "therapy"
    ])
    .build()

AppMetrica.report(event: event)

通过推广活动预约医生

用户打开七嘟医疗App的主屏幕，看到一张卡片：“预约检查，享20%折扣”。
AppMetrica.reportEvent(
    ProductFlowEvent.offerShown("checkup_discount_q2", "service")
        .withProductId("doctor_appointment")
        .withBenefitType("discount_percentage")
        .withReferrer(
                OfferReferrer.newBuilder()
                    .withType("banner")
                    .withIdentifier("main_checkup_banner")
                    .withScreen("main")
                    .build()
        )
        .withPayload(mapOf(
            "clinic_id" to "clinic_123",
            "specialization" to "therapy",
            "discount_value" to "20",
            "campaign_id" to "health_checkup_q2"
        ))
        .build()
)

let event = ProductFlowEvents.offerShown(productOfferId: "checkup_discount_q2", offerType: "service")
    .withProductId("doctor_appointment")
    .withBenefitType("discount_percentage")
    .withReferrer(OfferReferrer(type: "banner", identifier: "main_checkup_banner", screen: "main"))
    .withPayload([
        "clinic_id": "clinic_123",
        "specialization": "therapy",
        "discount_value": "20",
        "campaign_id": "health_checkup_q2"
    ])
    .build()

AppMetrica.report(event: event)
用户开始预约医生。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStart("doctor_appointment")
        .withProductOfferId("checkup_discount_q2")
        .build()
)

let event = ProductFlowEvents.flowStart(productId: "doctor_appointment")
    .withProductOfferId("checkup_discount_q2")
    .build()

AppMetrica.report(event: event)
用户选择医生。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("doctor_appointment", "doctor_selection")
        .withProductOfferId("checkup_discount_q2")
        .withStepOption("therapist")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "doctor_appointment", stepType: "doctor_selection")
    .withProductOfferId("checkup_discount_q2")
    .withStepOption("therapist")
    .build()

AppMetrica.report(event: event)
用户选择预约日期和时间。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("doctor_appointment", "timeslot_selection")
        .withProductOfferId("checkup_discount_q2")
        .withStepOption("2026-06-10_14:30")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "doctor_appointment", stepType: "timeslot_selection")
    .withProductOfferId("checkup_discount_q2")
    .withStepOption("2026-06-10_14:30")
    .build()

AppMetrica.report(event: event)
预约已成功创建。
AppMetrica.reportEvent(
    ProductFlowEvent.flowResultForProduct(ProductFlowStatus.SUCCESS, "doctor_appointment")
        .withProductOfferId("checkup_discount_q2")
        .withPayload(mapOf(
            "appointment_id" to "appointment_555",
            "doctor_specialization" to "therapy",
            "clinic_id" to "clinic_123",
            "discount_applied" to "true"
        ))
        .build()
)

let event = ProductFlowEvents.flowResult(productId: "doctor_appointment", status: .success)
    .withProductOfferId("checkup_discount_q2")
    .withPayload([
        "appointment_id": "appointment_555",
        "doctor_specialization": "therapy",
        "clinic_id": "clinic_123",
        "discount_applied": "true"
    ])
    .build()

AppMetrica.report(event: event)

美容 / 健康

SPA预订（预付款）

用户打开SPA沙龙App，看到一个优惠刊登：“在线支付享20%折扣的SPA套餐”。
AppMetrica.reportEvent(
    ProductFlowEvent.offerShown("spa_weekend_offer", "service")
        .withProductId("spa_booking")
        .withBenefitType("discount_percentage")
        .withReferrer(
                OfferReferrer.newBuilder()
                    .withType("banner")
                    .withIdentifier("spa_weekend_banner")
                    .withScreen("main")
                    .build()
        )
        .withPrice(OfferPrice(9600.0, "RUB"))
        .withPayload(mapOf(
            "service_type" to "spa_program",
            "discount_value" to "20",
            "original_price" to "12000",
            "campaign_id" to "spa_weekend_q2"
        ))
        .build()
)

let event = ProductFlowEvents.offerShown(productOfferId: "spa_weekend_offer", offerType: "service")
    .withProductId("spa_booking")
    .withBenefitType("discount_percentage")
    .withReferrer(OfferReferrer(type: "banner", identifier: "spa_weekend_banner", screen: "main"))
    .withPrice(OfferPrice(amount: 9600.0, unit: "RUB"))
    .withPayload([
        "service_type": "spa_program",
        "discount_value": "20",
        "original_price": "12000",
        "campaign_id": "spa_weekend_q2"
    ])
    .build()

AppMetrica.report(event: event)
用户开始预订SPA。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStart("spa_booking")
        .withProductOfferId("spa_weekend_offer")
        .build()
)

let event = ProductFlowEvents.flowStart(productId: "spa_booking")
    .withProductOfferId("spa_weekend_offer")
    .build()

AppMetrica.report(event: event)
用户选择 SPA 程序。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("spa_booking", "service_selection")
        .withProductOfferId("spa_weekend_offer")
        .withStepOption("relax_spa_program")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "spa_booking", stepType: "service_selection")
    .withProductOfferId("spa_weekend_offer")
    .withStepOption("relax_spa_program")
    .build()

AppMetrica.report(event: event)
用户选择访问日期和时间。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("spa_booking", "timeslot_selection")
        .withProductOfferId("spa_weekend_offer")
        .withStepOption("2026-06-15_18:00")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "spa_booking", stepType: "timeslot_selection")
    .withProductOfferId("spa_weekend_offer")
    .withStepOption("2026-06-15_18:00")
    .build()

AppMetrica.report(event: event)
用户继续进行预付款。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("spa_booking", "prepayment")
        .withProductOfferId("spa_weekend_offer")
        .withStepOption("bank_card")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "spa_booking", stepType: "prepayment")
    .withProductOfferId("spa_weekend_offer")
    .withStepOption("bank_card")
    .build()

AppMetrica.report(event: event)
预付款成功，预订已确认。
AppMetrica.reportEvent(
    ProductFlowEvent.flowResultForProduct(ProductFlowStatus.SUCCESS, "spa_booking")
        .withProductOfferId("spa_weekend_offer")
        .withPrice(OfferPrice(9600.0, "RUB"))
        .withPayload(mapOf(
            "booking_id" to "spa_booking_555",
            "service_type" to "relax_spa_program",
            "prepayment_amount" to "3000",
            "remaining_amount" to "6600",
            "payment_status" to "partially_paid"
        ))
        .build()
)

let event = ProductFlowEvents.flowResult(productId: "spa_booking", status: .success)
    .withProductOfferId("spa_weekend_offer")
    .withPrice(OfferPrice(amount: 9600.0, unit: "RUB"))
    .withPayload([
        "booking_id": "spa_booking_555",
        "service_type": "relax_spa_program",
        "prepayment_amount": "3000",
        "remaining_amount": "6600",
        "payment_status": "partially_paid"
    ])
    .build()

AppMetrica.report(event: event)
之后，SPA沙龙通过S2S确认用户确实参加了治疗。
flowResult(
    productId = "spa_booking",
    productOfferId = "spa_weekend_offer",
    status = "成功",
    price = OfferPrice(6600.0, "RUB"),
    payload = mapOf(
        "booking_id" to "spa_booking_555",
        "visit_status" to "已完成",
        "service_type" to "放松水疗项目",
        "decision_source" to "s2s"
    )
)

通过S2S方案发送推荐事件将在未来的某个版本中通过POST API实现。 当前文档提供了一个示例脚本，演示了预期的集成方法。

美甲预约

用户打开沙龙App，看到一个优惠券：“首次访问折扣15%”。
AppMetrica.reportEvent(
    ProductFlowEvent.offerShown("first_visit_nails", "service")
        .withProductId("beauty_appointment")
        .withBenefitType("discount_percentage")
        .withReferrer(
                OfferReferrer.newBuilder()
                    .withType("popup")
                    .withIdentifier("new_user_discount_popup")
                    .withScreen("main")
                    .build()
        )
        .withPayload(mapOf(
            "service_type" to "manicure",
            "discount_value" to "15",
            "campaign_id" to "new_clients_q2"
        ))
        .build()
)

let event = ProductFlowEvents.offerShown(productOfferId: "first_visit_nails", offerType: "service")
    .withProductId("beauty_appointment")
    .withBenefitType("discount_percentage")
    .withReferrer(OfferReferrer(type: "popup", identifier: "new_user_discount_popup", screen: "main"))
    .withPayload([
        "service_type": "manicure",
        "discount_value": "15",
        "campaign_id": "new_clients_q2"
    ])
    .build()

AppMetrica.report(event: event)
用户开始在美容院预约。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStart("beauty_appointment")
        .withProductOfferId("first_visit_nails")
        .build()
)

let event = ProductFlowEvents.flowStart(productId: "beauty_appointment")
    .withProductOfferId("first_visit_nails")
    .build()

AppMetrica.report(event: event)
用户选择一个服务。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("beauty_appointment", "service_selection")
        .withProductOfferId("first_visit_nails")
        .withStepOption("manicure_gel")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "beauty_appointment", stepType: "service_selection")
    .withProductOfferId("first_visit_nails")
    .withStepOption("manicure_gel")
    .build()

AppMetrica.report(event: event)
用户选择主机。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("beauty_appointment", "master_selection")
        .withProductOfferId("first_visit_nails")
        .withStepOption("top_master")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "beauty_appointment", stepType: "master_selection")
    .withProductOfferId("first_visit_nails")
    .withStepOption("top_master")
    .build()

AppMetrica.report(event: event)
用户选择日期和时间。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("beauty_appointment", "timeslot_selection")
        .withProductOfferId("first_visit_nails")
        .withStepOption("2026-06-12_18:00")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "beauty_appointment", stepType: "timeslot_selection")
    .withProductOfferId("first_visit_nails")
    .withStepOption("2026-06-12_18:00")
    .build()

AppMetrica.report(event: event)
预约已成功创建。
AppMetrica.reportEvent(
    ProductFlowEvent.flowResultForProduct(ProductFlowStatus.SUCCESS, "beauty_appointment")
        .withProductOfferId("first_visit_nails")
        .withPayload(mapOf(
            "appointment_id" to "beauty_booking_987",
            "service_type" to "manicure_gel",
            "master_level" to "top_master",
            "discount_applied" to "true"
        ))
        .build()
)

let event = ProductFlowEvents.flowResult(productId: "beauty_appointment", status: .success)
    .withProductOfferId("first_visit_nails")
    .withPayload([
        "appointment_id": "beauty_booking_987",
        "service_type": "manicure_gel",
        "master_level": "top_master",
        "discount_applied": "true"
    ])
    .build()

AppMetrica.report(event: event)

理发染发预约并随后取消

用户打开美发店应用，独立开始预约剪发和染发。 没有提供任何优惠或促销方案。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStart("beauty_appointment")
        .withPayload(mapOf("entry_point" to "catalog", "service_category" to "hair"))
        .build()
)

let event = ProductFlowEvents.flowStart(productId: "beauty_appointment")
    .withPayload(["entry_point": "catalog", "service_category": "hair"])
    .build()

AppMetrica.report(event: event)
用户选择服务：剪发和染发。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("beauty_appointment", "service_selection")
        .withStepOption("haircut_coloring")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "beauty_appointment", stepType: "service_selection")
    .withStepOption("haircut_coloring")
    .build()

AppMetrica.report(event: event)
用户选择主机。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("beauty_appointment", "master_selection")
        .withStepOption("top_master")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "beauty_appointment", stepType: "master_selection")
    .withStepOption("top_master")
    .build()

AppMetrica.report(event: event)
用户选择预约日期和时间。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("beauty_appointment", "timeslot_selection")
        .withStepOption("2026-06-20_15:00")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "beauty_appointment", stepType: "timeslot_selection")
    .withStepOption("2026-06-20_15:00")
    .build()

AppMetrica.report(event: event)
预约已成功创建。
AppMetrica.reportEvent(
    ProductFlowEvent.flowResultForProduct(ProductFlowStatus.SUCCESS, "beauty_appointment")
        .withPayload(mapOf(
            "booking_id" to "beauty_booking_777",
            "service_type" to "haircut_coloring",
            "master_level" to "top_master",
            "booking_status" to "confirmed"
        ))
        .build()
)

let event = ProductFlowEvents.flowResult(productId: "beauty_appointment", status: .success)
    .withPayload([
        "booking_id": "beauty_booking_777",
        "service_type": "haircut_coloring",
        "master_level": "top_master",
        "booking_status": "confirmed"
    ])
    .build()

AppMetrica.report(event: event)
后来，用户通过应用程序取消了预约。
AppMetrica.reportEvent(
    ProductFlowEvent.flowResultForProduct(ProductFlowStatus.CANCELLED, "beauty_appointment")
        .withPayload(mapOf(
            "booking_id" to "beauty_booking_777",
            "cancellation_reason" to "client_cancelled",
            "cancellation_source" to "app"
        ))
        .build()
)

let event = ProductFlowEvents.flowResult(productId: "beauty_appointment", status: .cancelled)
    .withPayload([
        "booking_id": "beauty_booking_777",
        "cancellation_reason": "client_cancelled",
        "cancellation_source": "app"
    ])
    .build()

AppMetrica.report(event: event)
或美容院通过 S2S 报告预约已取消。
flowResult(
    productId = "beauty_appointment",
    productOfferId = null,
    status = "已取消",
    payload = mapOf(
        "booking_id" to "beauty_booking_777",
        "cancellation_reason" to "客户取消",
        "decision_source" to "s2s"
    )
)

通过S2S方案发送推广事件将在未来的某个版本中通过POST API实现。 当前文档提供了一个示例脚本，演示了预期的集成方法。

Subscription / Media

试用订阅无需单独的流程启动

用户收到推送通知：“免费试用 Premium 30 天”。
AppMetrica.reportEvent(
    ProductFlowEvent.offerShown("premium_trial_30d", "subscription")
        .withProductId("premium_subscription")
        .withBenefitType("trial")
        .withReferrer(
                OfferReferrer.newBuilder()
                    .withType("notification")
                    .withIdentifier("premium_trial_push")
                    .build()
        )
        .withPayload(mapOf(
            "trial_days" to "30",
            "subscription_plan" to "premium_monthly",
            "campaign_id" to "trial_reactivation_2026"
        ))
        .build()
)

let event = ProductFlowEvents.offerShown(productOfferId: "premium_trial_30d", offerType: "subscription")
    .withProductId("premium_subscription")
    .withBenefitType("trial")
    .withReferrer(OfferReferrer(type: "notification", identifier: "premium_trial_push"))
    .withPayload([
        "trial_days": "30",
        "subscription_plan": "premium_monthly",
        "campaign_id": "trial_reactivation_2026"
    ])
    .build()

AppMetrica.report(event: event)
用户点击推送，立即激活试用。 没有单独的排序过程，因此可以省略 flowStart。
AppMetrica.reportEvent(
    ProductFlowEvent.flowResultForProduct(ProductFlowStatus.SUCCESS, "premium_subscription")
        .withProductOfferId("premium_trial_30d")
        .withPayload(mapOf(
            "trial_days" to "30",
            "subscription_plan" to "premium_monthly",
            "activation_source" to "push"
        ))
        .build()
)

let event = ProductFlowEvents.flowResult(productId: "premium_subscription", status: .success)
    .withProductOfferId("premium_trial_30d")
    .withPayload([
        "trial_days": "30",
        "subscription_plan": "premium_monthly",
        "activation_source": "push"
    ])
    .build()

AppMetrica.report(event: event)

视频平台和在线电影院

试用订阅激活

用户打开在线电影应用，看到全屏付费墙：“30天免费 Premium”。
AppMetrica.reportEvent(
    ProductFlowEvent.offerShown("premium_trial_30d", "subscription")
        .withProductId("premium_subscription")
        .withBenefitType("trial")
        .withReferrer(
                OfferReferrer.newBuilder()
                    .withType("screen")
                    .withIdentifier("premium_paywall")
                    .withScreen("home")
                    .build()
        )
        .withPayload(mapOf(
            "trial_days" to "30",
            "subscription_plan" to "premium_monthly",
            "campaign_id" to "summer_trial_2026"
        ))
        .build()
)

let event = ProductFlowEvents.offerShown(productOfferId: "premium_trial_30d", offerType: "subscription")
    .withProductId("premium_subscription")
    .withBenefitType("trial")
    .withReferrer(OfferReferrer(type: "screen", identifier: "premium_paywall", screen: "home"))
    .withPayload([
        "trial_days": "30",
        "subscription_plan": "premium_monthly",
        "campaign_id": "summer_trial_2026"
    ])
    .build()

AppMetrica.report(event: event)
用户点击“试用”。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStart("premium_subscription")
        .withProductOfferId("premium_trial_30d")
        .build()
)

let event = ProductFlowEvents.flowStart(productId: "premium_subscription")
    .withProductOfferId("premium_trial_30d")
    .build()

AppMetrica.report(event: event)
用户选择一个计划。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("premium_subscription", "plan_selection")
        .withProductOfferId("premium_trial_30d")
        .withStepOption("premium_monthly")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "premium_subscription", stepType: "plan_selection")
    .withProductOfferId("premium_trial_30d")
    .withStepOption("premium_monthly")
    .build()

AppMetrica.report(event: event)
用户添加支付方式。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("premium_subscription", "payment_method")
        .withProductOfferId("premium_trial_30d")
        .withStepOption("bank_card")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "premium_subscription", stepType: "payment_method")
    .withProductOfferId("premium_trial_30d")
    .withStepOption("bank_card")
    .build()

AppMetrica.report(event: event)
试用订阅已成功激活。
AppMetrica.reportEvent(
    ProductFlowEvent.flowResultForProduct(ProductFlowStatus.SUCCESS, "premium_subscription")
        .withProductOfferId("premium_trial_30d")
        .withPayload(mapOf(
            "subscription_plan" to "premium_monthly",
            "trial_days" to "30",
            "autorenew_enabled" to "true"
        ))
        .build()
)

let event = ProductFlowEvents.flowResult(productId: "premium_subscription", status: .success)
    .withProductOfferId("premium_trial_30d")
    .withPayload([
        "subscription_plan": "premium_monthly",
        "trial_days": "30",
        "autorenew_enabled": "true"
    ])
    .build()

AppMetrica.report(event: event)

租影

用户打开电影卡片，看到一个推荐：“租看此电影，299 RUB”。
AppMetrica.reportEvent(
    ProductFlowEvent.offerShown("movie_rental_offer", "digital_good")
        .withProductId("movie_rental")
        .withBenefitType("discount_absolute")
        .withReferrer(
                OfferReferrer.newBuilder()
                    .withType("button")
                    .withIdentifier("rent_movie_button")
                    .withScreen("movie_details")
                    .build()
        )
        .withPrice(OfferPrice(299.0, "RUB"))
        .withPayload(mapOf(
            "movie_id" to "movie_987",
            "movie_title" to "SciFi Adventure"
        ))
        .build()
)

let event = ProductFlowEvents.offerShown(productOfferId: "movie_rental_offer", offerType: "digital_good")
    .withProductId("movie_rental")
    .withBenefitType("discount_absolute")
    .withReferrer(OfferReferrer(type: "button", identifier: "rent_movie_button", screen: "movie_details"))
    .withPrice(OfferPrice(amount: 299.0, unit: "RUB"))
    .withPayload([
        "movie_id": "movie_987",
        "movie_title": "SciFi Adventure"
    ])
    .build()

AppMetrica.report(event: event)
用户开始租赁流程。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStart("movie_rental")
        .withProductOfferId("movie_rental_offer")
        .build()
)

let event = ProductFlowEvents.flowStart(productId: "movie_rental")
    .withProductOfferId("movie_rental_offer")
    .build()

AppMetrica.report(event: event)
用户确认支付。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("movie_rental", "payment_confirmation")
        .withProductOfferId("movie_rental_offer")
        .withStepOption("bank_card")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "movie_rental", stepType: "payment_confirmation")
    .withProductOfferId("movie_rental_offer")
    .withStepOption("bank_card")
    .build()

AppMetrica.report(event: event)
电影租阅成功完成。
AppMetrica.reportEvent(
    ProductFlowEvent.flowResultForProduct(ProductFlowStatus.SUCCESS, "movie_rental")
        .withProductOfferId("movie_rental_offer")
        .withPayload(mapOf(
            "movie_id" to "movie_987",
            "rental_duration_hours" to "48",
            "payment_status" to "paid"
        ))
        .build()
)

let event = ProductFlowEvents.flowResult(productId: "movie_rental", status: .success)
    .withProductOfferId("movie_rental_offer")
    .withPayload([
        "movie_id": "movie_987",
        "rental_duration_hours": "48",
        "payment_status": "paid"
    ])
    .build()

AppMetrica.report(event: event)

购买在线电影放映的票

用户打开电影卡片，看到一个广告：“购买在线观看的票，500 RUB”。
AppMetrica.reportEvent(
    ProductFlowEvent.offerShown("online_premiere_ticket_offer", "digital_good")
        .withProductId("online_event_ticket")
        .withReferrer(
                OfferReferrer.newBuilder()
                    .withType("button")
                    .withIdentifier("buy_ticket_button")
                    .withScreen("premiere_details")
                    .build()
        )
        .withPrice(OfferPrice(500.0, "RUB"))
        .withPayload(mapOf(
            "event_id" to "premiere_987",
            "event_type" to "online_premiere",
            "content_id" to "movie_987"
        ))
        .build()
)

let event = ProductFlowEvents.offerShown(productOfferId: "online_premiere_ticket_offer", offerType: "digital_good")
    .withProductId("online_event_ticket")
    .withReferrer(OfferReferrer(type: "button", identifier: "buy_ticket_button", screen: "premiere_details"))
    .withPrice(OfferPrice(amount: 500.0, unit: "RUB"))
    .withPayload([
        "event_id": "premiere_987",
        "event_type": "online_premiere",
        "content_id": "movie_987"
    ])
    .build()

AppMetrica.report(event: event)
用户开始购买票。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStart("online_event_ticket")
        .withProductOfferId("online_premiere_ticket_offer")
        .build()
)

let event = ProductFlowEvents.flowStart(productId: "online_event_ticket")
    .withProductOfferId("online_premiere_ticket_offer")
    .build()

AppMetrica.report(event: event)
用户选择票务类型。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("online_event_ticket", "ticket_type_selection")
        .withProductOfferId("online_premiere_ticket_offer")
        .withStepOption("standard")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "online_event_ticket", stepType: "ticket_type_selection")
    .withProductOfferId("online_premiere_ticket_offer")
    .withStepOption("standard")
    .build()

AppMetrica.report(event: event)
用户确认支付。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("online_event_ticket", "payment_confirmation")
        .withProductOfferId("online_premiere_ticket_offer")
        .withStepOption("bank_card")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "online_event_ticket", stepType: "payment_confirmation")
    .withProductOfferId("online_premiere_ticket_offer")
    .withStepOption("bank_card")
    .build()

AppMetrica.report(event: event)
票据已成功购买。
AppMetrica.reportEvent(
    ProductFlowEvent.flowResultForProduct(ProductFlowStatus.SUCCESS, "online_event_ticket")
        .withProductOfferId("online_premiere_ticket_offer")
        .withPayload(mapOf(
            "event_id" to "premiere_987",
            "content_id" to "movie_987",
            "ticket_type" to "standard",
            "payment_status" to "paid"
        ))
        .build()
)

let event = ProductFlowEvents.flowResult(productId: "online_event_ticket", status: .success)
    .withProductOfferId("online_premiere_ticket_offer")
    .withPayload([
        "event_id": "premiere_987",
        "content_id": "movie_987",
        "ticket_type": "standard",
        "payment_status": "paid"
    ])
    .build()

AppMetrica.report(event: event)

忠诚度 / 促销

获取促销码而不需要复杂流程

用户在结算页面看到一个弹窗：“获取促销码 SUMMER20”。
AppMetrica.reportEvent(
    ProductFlowEvent.offerShown("promo_summer_20", "digital_good")
        .withProductId("promo_code")
        .withBenefitType("discount_absolute")
        .withReferrer(
                OfferReferrer.newBuilder()
                    .withType("popup")
                    .withIdentifier("summer_promo_popup")
                    .withScreen("checkout")
                    .build()
        )
        .withPayload(mapOf(
            "promo_code" to "SUMMER20",
            "discount_value" to "20",
            "currency" to "EUR",
            "min_order_value" to "100"
        ))
        .build()
)

let event = ProductFlowEvents.offerShown(productOfferId: "promo_summer_20", offerType: "digital_good")
    .withProductId("promo_code")
    .withBenefitType("discount_absolute")
    .withReferrer(OfferReferrer(type: "popup", identifier: "summer_promo_popup", screen: "checkout"))
    .withPayload([
        "promo_code": "SUMMER20",
        "discount_value": "20",
        "currency": "EUR",
        "min_order_value": "100"
    ])
    .build()

AppMetrica.report(event: event)
用户点击“获取促销码”。 没有单独的流程，因此结果可以立即发送。
AppMetrica.reportEvent(
    ProductFlowEvent.flowResultForProduct(ProductFlowStatus.SUCCESS, "promo_code")
        .withProductOfferId("promo_summer_20")
        .withPayload(mapOf("promo_code" to "SUMMER20", "copied_to_clipboard" to "true"))
        .build()
)

let event = ProductFlowEvents.flowResult(productId: "promo_code", status: .success)
    .withProductOfferId("promo_summer_20")
    .withPayload(["promo_code": "SUMMER20", "copied_to_clipboard": "true"])
    .build()

AppMetrica.report(event: event)

保险

保险申请，服务器端决策（S2S 结果）

用户打开行程页面，看到一个按钮：“添加保险，享15%折扣”。
AppMetrica.reportEvent(
    ProductFlowEvent.offerShown("travel_insurance_offer", "insurance")
        .withProductId("travel_insurance")
        .withBenefitType("discount_percentage")
        .withReferrer(
                OfferReferrer.newBuilder()
                    .withType("button")
                    .withIdentifier("trip_details_insurance_button")
                    .withScreen("trip_details")
                    .build()
        )
        .withPayload(mapOf(
            "campaign_id" to "travel_insurance_q2",
            "discount_value" to "15",
            "destination_country" to "Serbia",
            "trip_duration_days" to "7"
        ))
        .build()
)

let event = ProductFlowEvents.offerShown(productOfferId: "travel_insurance_offer", offerType: "insurance")
    .withProductId("travel_insurance")
    .withBenefitType("discount_percentage")
    .withReferrer(OfferReferrer(type: "button", identifier: "trip_details_insurance_button", screen: "trip_details"))
    .withPayload([
        "campaign_id": "travel_insurance_q2",
        "discount_value": "15",
        "destination_country": "Serbia",
        "trip_duration_days": "7"
    ])
    .build()

AppMetrica.report(event: event)
用户开始办理保险申请。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStart("travel_insurance")
        .withProductOfferId("travel_insurance_offer")
        .build()
)

let event = ProductFlowEvents.flowStart(productId: "travel_insurance")
    .withProductOfferId("travel_insurance_offer")
    .build()

AppMetrica.report(event: event)
用户选择覆盖范围。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("travel_insurance", "coverage_selection")
        .withProductOfferId("travel_insurance_offer")
        .withStepOption("standard")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "travel_insurance", stepType: "coverage_selection")
    .withProductOfferId("travel_insurance_offer")
    .withStepOption("standard")
    .build()

AppMetrica.report(event: event)
用户输入自己的信息。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("travel_insurance", "traveler_details")
        .withProductOfferId("travel_insurance_offer")
        .withStepOption("manual_input")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "travel_insurance", stepType: "traveler_details")
    .withProductOfferId("travel_insurance_offer")
    .withStepOption("manual_input")
    .build()

AppMetrica.report(event: event)
应用程序已提交审核。
AppMetrica.reportEvent(
    ProductFlowEvent.flowResultForProduct(ProductFlowStatus.PENDING, "travel_insurance")
        .withProductOfferId("travel_insurance_offer")
        .withPayload(mapOf(
            "application_id" to "insurance_app_987",
            "coverage_type" to "standard",
            "destination_country" to "Serbia"
        ))
        .build()
)

let event = ProductFlowEvents.flowResult(productId: "travel_insurance", status: .pending)
    .withProductOfferId("travel_insurance_offer")
    .withPayload([
        "application_id": "insurance_app_987",
        "coverage_type": "standard",
        "destination_country": "Serbia"
    ])
    .build()

AppMetrica.report(event: event)
之后，保险公司通过 S2S 发送最终结果。
flowResult(
    productId = "travel_insurance",
    productOfferId = "travel_insurance_offer",
    status = "success",
    payload = mapOf(
        "application_id" to "insurance_app_987",
        "policy_id" to "policy_555",
        "decision_source" to "s2s"
    )
)

通过S2S方案发送推广事件将在未来的某个版本中通过POST API实现。 当前文档提供了一个示例脚本，演示了预期的集成方法。

Gaming

购买游戏套餐

用户打开游戏商店，看到一个广告横幅：“初始包：硬币 + 宝石 + 额外物品”。
AppMetrica.reportEvent(
    ProductFlowEvent.offerShown("starter_bundle_offer", "bundle")
        .withProductId("starter_bundle")
        .withBenefitType("bundle_extra")
        .withReferrer(
                OfferReferrer.newBuilder()
                    .withType("banner")
                    .withIdentifier("store_starter_bundle_banner")
                    .withScreen("game_store")
                    .build()
        )
        .withPrice(OfferPrice(4.99, "USD"))
        .withPayload(mapOf(
            "bundle_id" to "starter_bundle",
            "bonus_items" to "coins,gems,sword_skin",
            "price_tier" to "low",
            "campaign_id" to "starter_pack_campaign"
        ))
        .build()
)

let event = ProductFlowEvents.offerShown(productOfferId: "starter_bundle_offer", offerType: "bundle")
    .withProductId("starter_bundle")
    .withBenefitType("bundle_extra")
    .withReferrer(OfferReferrer(type: "banner", identifier: "store_starter_bundle_banner", screen: "game_store"))
    .withPrice(OfferPrice(amount: 4.99, unit: "USD"))
    .withPayload([
        "bundle_id": "starter_bundle",
        "bonus_items": "coins",
        "price_tier": "low",
        "campaign_id": "starter_pack_campaign"
    ])
    .build()

AppMetrica.report(event: event)
用户打开套餐购买。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStart("starter_bundle")
        .withProductOfferId("starter_bundle_offer")
        .build()
)

let event = ProductFlowEvents.flowStart(productId: "starter_bundle")
    .withProductOfferId("starter_bundle_offer")
    .build()

AppMetrica.report(event: event)
用户确认购买。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("starter_bundle", "purchase_confirmation")
        .withProductOfferId("starter_bundle_offer")
        .withStepOption("confirmed")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "starter_bundle", stepType: "purchase_confirmation")
    .withProductOfferId("starter_bundle_offer")
    .withStepOption("confirmed")
    .build()

AppMetrica.report(event: event)
购买成功。
AppMetrica.reportEvent(
    ProductFlowEvent.flowResultForProduct(ProductFlowStatus.SUCCESS, "starter_bundle")
        .withProductOfferId("starter_bundle_offer")
        .withPrice(OfferPrice(4.99, "USD"))
        .withPayload(mapOf(
            "bundle_id" to "starter_bundle",
            "payment_status" to "paid",
            "bonus_items_granted" to "true"
        ))
        .build()
)

let event = ProductFlowEvents.flowResult(productId: "starter_bundle", status: .success)
    .withProductOfferId("starter_bundle_offer")
    .withPrice(OfferPrice(amount: 4.99, unit: "USD"))
    .withPayload([
        "bundle_id": "starter_bundle",
        "payment_status": "paid",
        "bonus_items_granted": "true"
    ])
    .build()

AppMetrica.report(event: event)

调查和产品评价

一页式购买后调查

用户已完成购买，看到屏幕：“评价产品”。 没有协议，可以省略 flowStart。
AppMetrica.reportEvent(
    ProductFlowEvent.flowResultForProduct(ProductFlowStatus.SUCCESS, "product_review")
        .withPayload(mapOf(
            "survey_id" to "post_purchase_review",
            "product_id" to "sku_12345",
            "rating" to "5",
            "has_comment" to "true"
        ))
        .build()
)

let event = ProductFlowEvents.flowResult(productId: "product_review", status: .success)
    .withPayload([
        "survey_id": "post_purchase_review",
        "product_id": "sku_12345",
        "rating": "5",
        "has_comment": "true"
    ])
    .build()

AppMetrica.report(event: event)

多步骤购后调查

用户已完成购买，看到屏幕提示：“帮助我们改进推荐 — 回答几个问题”。 没有券，但有多步流程。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStart("product_review_survey")
        .withPayload(mapOf(
            "survey_id" to "post_purchase_review",
            "product_id" to "sku_12345",
            "entry_point" to "order_success_screen"
        ))
        .build()
)

let event = ProductFlowEvents.flowStart(productId: "product_review_survey")
    .withPayload([
        "survey_id": "post_purchase_review",
        "product_id": "sku_12345",
        "entry_point": "order_success_screen"
    ])
    .build()

AppMetrica.report(event: event)
用户对产品进行评分。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("product_review_survey", "rating")
        .withStepOption("5")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "product_review_survey", stepType: "rating")
    .withStepOption("5")
    .build()

AppMetrica.report(event: event)
用户回答了他们喜欢什么。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("product_review_survey", "positive_feedback")
        .withStepOption("quality")
        .build()
)

let event = ProductFlowEvents.flowStep(productId: "product_review_survey", stepType: "positive_feedback")
    .withStepOption("quality")
    .build()

AppMetrica.report(event: event)
用户进入评论步骤但关闭了屏幕。 最后一个 flowStep（在 flowResult(cancelled) 之前）有助于确定用户流失发生的位置。
AppMetrica.reportEvent(
    ProductFlowEvent.flowStepForProduct("product_review_survey", "comment")
        .withStepOption("optional_text")
        .build()
)

AppMetrica.reportEvent(
    ProductFlowEvent.flowResultForProduct(ProductFlowStatus.CANCELLED, "product_review_survey")
        .withPayload(mapOf(
            "survey_id" to "post_purchase_review",
            "product_id" to "sku_12345",
            "last_completed_step" to "comment"
        ))
        .build()
)

let commentStep = ProductFlowEvents.flowStep(productId: "product_review_survey", stepType: "comment")
    .withStepOption("optional_text")
    .build()

AppMetrica.report(event: commentStep)

let result = ProductFlowEvents.flowResult(productId: "product_review_survey", status: .cancelled)
    .withPayload([
        "survey_id": "post_purchase_review",
        "product_id": "sku_12345",
        "last_completed_step": "comment"
    ])
    .build()

AppMetrica.report(event: result)
用户已完成调查。
AppMetrica.reportEvent(
    ProductFlowEvent.flowResultForProduct(ProductFlowStatus.SUCCESS, "product_review_survey")
        .withPayload(mapOf(
            "survey_id" to "post_purchase_review",
            "product_id" to "sku_12345",
            "rating" to "5",
            "positive_feedback" to "quality",
            "has_comment" to "true"
        ))
        .build()
)

let event = ProductFlowEvents.flowResult(productId: "product_review_survey", status: .success)
    .withPayload([
        "survey_id": "post_purchase_review",
        "product_id": "sku_12345",
        "rating": "5",
        "positive_feedback": "quality",
        "has_comment": "true"
    ])
    .build()

AppMetrica.report(event: event)

如何阅读标记场景

offerShown
若用户实际看到了推广内容（如横幅广告、弹窗、推送通知、按钮、卡片或其他推广模块），则会发送。
flowStart
若用户有单独的开始步骤（如下单、激活或多步骤流程），则会发送。
flowStep
用于发送重要的中间步骤。 尤其有用，当你需要确定用户在哪个阶段停止或放弃场景时。
flowResult
当场景结果已知时总会发送。

如果结果不是立即可得，首先会发送中间结果：

AppMetrica.reportEvent(
    ProductFlowEvent.flowResultForProduct(ProductFlowStatus.PENDING, "...")
        .withProductOfferId("...")
        .build()
)

let event = ProductFlowEvents.flowResult(productId: "...", status: .pending)
    .withProductOfferId("...")
    .build()

AppMetrica.report(event: event)

之后，最终结果通过 S2S 发送：

AppMetrica.reportEvent(
    ProductFlowEvent.flowResultForProduct(ProductFlowStatus.SUCCESS, "...")
        .withProductOfferId("...")
        .build()
)

let event = ProductFlowEvents.flowResult(productId: "...", status: .success)
    .withProductOfferId("...")
    .build()

AppMetrica.report(event: event)

或

AppMetrica.reportEvent(
    ProductFlowEvent.flowResultForProduct(ProductFlowStatus.DECLINED, "...")
        .withProductOfferId("...")
        .build()
)

let event = ProductFlowEvents.flowResult(productId: "...", status: .declined)
    .withProductOfferId("...")
    .build()

AppMetrica.report(event: event)

状态

含义

成功

成功完成

拒绝

被第三方拒绝

等待

等待决定

已取消

已被用户取消

已过期

优惠或会话已过期

失败

技术错误

如何判断新事件标记是否适合您

我们建议使用此标记方案，如果您的应用有：

  • offers;
  • proposal cards;
  • onboarding scenarios;
  • 订单下单场景;
  • 金融产品应用场景；
  • booking scenarios;
  • subscription scenarios;
  • 升级套餐或产品的场景；
  • approval scenarios;
  • funnel analytics.

该架构在当前实现中会尤其有用：

  • 所有事件都作为自定义事件发送；
  • 事件难以相互关联；
  • 相同的步骤名称不同；
  • 阶段间转换分析较困难；
  • 对产品漏斗没有统一的方法。

从自定义事件迁移

如果您已经使用自定义事件，可以逐步迁移：新的事件可以与现有的自定义事件并行发送。

新的标准事件不会占用自定义事件的限制，并允许您在迁移前验证集成的正确性和数据的完整性。

验证后，可以禁用相应的自定义事件。

如果您没有找到所需答案，可以通过反馈表单提交您的问题。 请尽可能详细地描述问题。 如果可能，请附上截图。

联系支持 为文档提出改进建议