Google Play のサブスクリプション価格変更を理解する：完全ガイド

\/\/ Backend service for initiating price migration
class PriceMigrationService(
    private val androidPublisher: AndroidPublisher
) {
    fun migrateSubscribersToNewPrice(
        packageName: String,
        productId: String,
        basePlanId: String,
        regions: List<String>,
        newPriceAmountMicros: Long,
        currencyCode: String
    ) {
        val regionalConfigs = regions.map { regionCode ->
            RegionalPriceMigrationConfig().apply {
                this.regionCode = regionCode
                this.priceIncreaseType = "OPT_IN" \/\/ or "OPT_OUT" if eligible
                this.oldestAllowedPriceVersionTime = null \/\/ migrate all legacy cohorts
            }
        }

        val request = MigratePricesRequest().apply {
            this.regionalPriceMigrationConfigs = regionalConfigs
        }

        androidPublisher
            .monetization()
            .subscriptions()
            .basePlans()
            .migratePrices(packageName, productId, basePlanId, request)
            .execute()
    }
}

class PriceChangeManager(
    private val backendApi: BackendApi
) {
    suspend fun checkForPriceChanges(userId: String): PriceChangeInfo? {
        val subscriptionStatus = backendApi.getSubscriptionStatus(userId)
        val priceChange = subscriptionStatus.pendingPriceChange ?: return null

        return when {
            priceChange.newPriceMicros < priceChange.currentPriceMicros -> {
                PriceChangeInfo.Decrease(
                    currentPrice = formatPrice(priceChange.currentPriceMicros),
                    newPrice = formatPrice(priceChange.newPriceMicros),
                    effectiveDate = priceChange.effectiveDate
                )
            }
            else -> {
                \/\/ Handle price increase (covered in next section)
                handlePriceIncrease(priceChange)
            }
        }
    }
}

\/\/ In your UI layer
fun showPriceDecreaseNotification(info: PriceChangeInfo.Decrease) {
    showBanner(
        title = "Good news!",
        message = "Your subscription price is decreasing from ${info.currentPrice} " +
            "to ${info.newPrice} starting ${formatDate(info.effectiveDate)}."
    )
}

class OptInPriceIncreaseManager(
    private val billingClient: BillingClient,
    private val backendApi: BackendApi
) {
    sealed class PriceIncreaseState {
        object None : PriceIncreaseState()
        data class Pending(
            val currentPrice: String,
            val newPrice: String,
            val effectiveDate: Instant,
            val inFreezePeriod: Boolean
        ) : PriceIncreaseState()
        object Accepted : PriceIncreaseState()
        object Declined : PriceIncreaseState()
    }

    suspend fun checkPriceIncreaseStatus(userId: String): PriceIncreaseState {
        val subscriptionStatus = backendApi.getSubscriptionStatus(userId)
        val priceChange = subscriptionStatus.pendingPriceChange

        if (priceChange == null || priceChange.newPriceMicros <= priceChange.currentPriceMicros) {
            return PriceIncreaseState.None
        }

        return when (priceChange.state) {
            "OUTSTANDING" -> {
                val freezePeriodEnd = priceChange.initiatedAt.plus(Duration.ofDays(7))
                PriceIncreaseState.Pending(
                    currentPrice = formatPrice(priceChange.currentPriceMicros),
                    newPrice = formatPrice(priceChange.newPriceMicros),
                    effectiveDate = priceChange.effectiveDate,
                    inFreezePeriod = Instant.now().isBefore(freezePeriodEnd)
                )
            }
            "CONFIRMED" -> PriceIncreaseState.Accepted
            "CANCELED" -> PriceIncreaseState.Declined
            else -> PriceIncreaseState.None
        }
    }

    fun showPriceIncreaseUI(
        activity: Activity,
        state: PriceIncreaseState.Pending
    ) {
        if (state.inFreezePeriod) {
            \/\/ During freeze period, show your own messaging
            showCustomPriceIncreaseDialog(
                currentPrice = state.currentPrice,
                newPrice = state.newPrice,
                effectiveDate = state.effectiveDate,
                onAcceptClick = { openPlayStoreSubscriptionSettings(activity) }
            )
        } else {
            \/\/ After freeze period, can also use Google's in app messaging
            showInAppMessage(activity)
        }
    }

    private fun showInAppMessage(activity: Activity) {
        val params = InAppMessageParams.newBuilder()
            .addInAppMessageCategoryToShow(
                InAppMessageParams.InAppMessageCategoryId.SUBSCRIPTION_PRICE_CHANGE
            )
            .build()

        billingClient.showInAppMessages(activity, params) { result ->
            \/\/ Handle the result
            when (result.responseCode) {
                InAppMessageResult.InAppMessageResponseCode.NO_ACTION_NEEDED -> {
                    \/\/ No price change message needed or user already responded
                }
                InAppMessageResult.InAppMessageResponseCode.SUBSCRIPTION_STATUS_UPDATED -> {
                    \/\/ User interacted with the message - refresh subscription status
                    refreshSubscriptionStatus()
                }
            }
        }
    }

    private fun openPlayStoreSubscriptionSettings(activity: Activity) {
        val intent = Intent(Intent.ACTION_VIEW).apply {
            data = Uri.parse(
                "<https:\/\/play.google.com\/store\/account\/subscriptions>"
            )
            setPackage("com.android.vending")
        }
        activity.startActivity(intent)
    }
}

fun showCustomPriceIncreaseDialog(
    currentPrice: String,
    newPrice: String,
    effectiveDate: Instant,
    onAcceptClick: () -> Unit
) {
    showDialog(
        title = "Subscription Update",
        message = """
            Starting ${formatDate(effectiveDate)}, your subscription will change
            from $currentPrice to $newPrice per month.

            Since you subscribed, we've added:
            \u2022 Advanced analytics dashboard
            \u2022 Offline mode for all content
            \u2022 Priority customer support
            \u2022 And 15+ other features

            To continue enjoying these features, please confirm the new price
            in your Play Store subscription settings.
        """.trimIndent(),
        positiveButton = "Review in Play Store" to onAcceptClick,
        negativeButton = "Maybe Later" to { \/* dismiss *\/ }
    )
}

fun handleOptOutPriceIncrease(priceChange: PriceChangeInfo) {
    \/\/ For opt-out increases, the state will be "CONFIRMED" rather than "OUTSTANDING"
    \/\/ Users will be charged the new price automatically unless they cancel

    showNotification(
        title = "Subscription Price Update",
        message = "Starting ${formatDate(priceChange.effectiveDate)}, " +
            "your subscription will be ${priceChange.newPrice}\/month. " +
            "No action needed to continue your subscription."
    )
}

class PriceChangeNotificationManager(
    private val billingClient: BillingClient
) {
    fun showPriceChangeNotificationIfNeeded(
        activity: Activity,
        priceIncreaseState: PriceIncreaseState
    ) {
        when (priceIncreaseState) {
            is PriceIncreaseState.Pending -> {
                \/\/ Always show some form of notification for pending increases
                if (priceIncreaseState.inFreezePeriod) {
                    showCustomNotificationBanner(activity, priceIncreaseState)
                } else {
                    \/\/ Use Google's in app messaging
                    showGoogleInAppMessage(activity)
                }
            }
            else -> {
                \/\/ No notification needed
            }
        }
    }

    private fun showCustomNotificationBanner(
        activity: Activity,
        state: PriceIncreaseState.Pending
    ) {
        \/\/ Show a subtle banner at the top of the screen
        val banner = PriceChangeBanner(activity).apply {
            setMessage(
                "Your subscription price will change to ${state.newPrice} " +
                "on ${formatDate(state.effectiveDate)}. Tap to review."
            )
            setOnClickListener {
                openPriceChangeDetails(activity, state)
            }
        }
        banner.show()
    }

    private fun showGoogleInAppMessage(activity: Activity) {
        val params = InAppMessageParams.newBuilder()
            .addInAppMessageCategoryToShow(
                InAppMessageParams.InAppMessageCategoryId.SUBSCRIPTION_PRICE_CHANGE
            )
            .build()

        billingClient.showInAppMessages(activity, params) { \/* handle result *\/ }
    }
}

\/\/ Backend notification handler
class PriceChangeNotificationHandler(
    private val subscriptionRepository: SubscriptionRepository,
    private val playDeveloperApi: AndroidPublisher
) {
    fun handlePriceChangeNotification(notification: DeveloperNotification) {
        val purchaseToken = notification.subscriptionNotification.purchaseToken

        when (notification.subscriptionNotification.notificationType) {
            NotificationType.SUBSCRIPTION_PRICE_CHANGE_UPDATED -> {
                \/\/ Query the current state of the price change
                val subscription = playDeveloperApi
                    .purchases()
                    .subscriptionsv2()
                    .get(packageName, purchaseToken)
                    .execute()

                val priceChangeState = subscription.lineItems[0]
                    .autoRenewingPlan
                    ?.priceChangeDetails

                if (priceChangeState != null) {
                    subscriptionRepository.updatePriceChangeStatus(
                        purchaseToken = purchaseToken,
                        state = priceChangeState.priceChangeState,
                        newPriceMicros = priceChangeState.newPrice?.priceMicros,
                        expectedNewPriceChargeTime = priceChangeState.expectedNewPriceChargeTime
                    )

                    \/\/ Notify app layer to update UI if needed
                    notifyPriceChangeUpdated(purchaseToken, priceChangeState)
                }
            }
        }
    }
}

fun checkForPriceChanges() {
    Purchases.sharedInstance.getCustomerInfoWith { customerInfo ->
        val entitlement = customerInfo.entitlements["premium"]

        \/\/ RevenueCat's CustomerInfo reflects current subscription state
        \/\/ including any pending price changes processed from RTDN

        if (entitlement?.isActive == true) {
            \/\/ Check for billing issues that might indicate price change problems
            entitlement.billingIssueDetectedAt?.let { issueDate ->
                showBillingRecoveryUI(customerInfo.managementURL)
            }
        }
    }
}

fun guideToPriceChangeAcceptance(customerInfo: CustomerInfo) {
    val managementUrl = customerInfo.managementURL

    showDialog(
        title = "Action Required",
        message = "Please review the upcoming changes to your subscription.",
        positiveButton = "Open Settings" to {
            openUrl(managementUrl)
        }
    )
}

\/\/ Your webhook handler
fun handleRevenueCatWebhook(event: WebhookEvent) {
    when (event.type) {
        "RENEWAL" -> {
            \/\/ Renewal completed - check if price changed
            val transaction = event.transaction
            if (transaction.priceInPurchasedCurrency != previousPrice) {
                \/\/ Price change took effect
                updateUserPricing(event.appUserId, transaction.priceInPurchasedCurrency)
            }
        }
        "CANCELLATION" -> {
            \/\/ User canceled, might be due to price change rejection
            val reason = event.cancellationReason
            if (reason == "PRICE_INCREASE") {
                \/\/ Track churn related to price changes
                analytics.trackPriceChangeChurn(event.appUserId)
            }
        }
    }
}

class PriceChangeAnalytics(
    private val analytics: AnalyticsService
) {
    fun trackPriceChangeOutcome(
        userId: String,
        originalPrice: Long,
        newPrice: Long,
        outcome: PriceChangeOutcome
    ) {
        analytics.track(
            event = "price_change_outcome",
            properties = mapOf(
                "user_id" to userId,
                "original_price_micros" to originalPrice,
                "new_price_micros" to newPrice,
                "increase_percentage" to calculatePercentage(originalPrice, newPrice),
                "outcome" to outcome.name
            )
        )
    }
}

enum class PriceChangeOutcome {
    ACCEPTED,
    DECLINED,
    SUBSCRIPTION_CANCELED,
    NO_RESPONSE_BEFORE_DEADLINE
}