Rork Max でリリースしたアプリの収益化フロー設計 — オファーコード・ウィンバック・プッシュ通知連動の実装

// iOS 側: オファーコード適用
import StoreKit
 
func applyPromotionalOffer(productId: String, offerSignature: SignedOffer) async throws {
    guard let product = try await Product.products(for: [productId]).first else {
        throw OfferError.productNotFound
    }
 
    let result = try await product.purchase(options: [
        .promotionalOffer(
            offerID: offerSignature.offerId,
            keyID: offerSignature.keyId,
            nonce: offerSignature.nonce,
            signature: offerSignature.signature,
            timestamp: offerSignature.timestamp
        )
    ])
 
    switch result {
    case .success(let verification):
        switch verification {
        case .verified(let transaction):
            await transaction.finish()
        case .unverified(_, let error):
            throw error
        }
    case .userCancelled:
        break
    case .pending:
        break
    @unknown default:
        break
    }
}
 
struct SignedOffer {
    let offerId: String
    let keyId: String
    let nonce: UUID
    let signature: Data
    let timestamp: Int64
}

// サーバー側: オファー署名生成（Node.js）
import { createSign } from "node:crypto";
 
interface OfferParams {
  appBundleId: string;
  productId: string;
  offerId: string;
  applicationUsername: string; // ユーザーの一意 ID
  privateKey: string; // PEM 形式の秘密鍵
  keyId: string; // App Store Connect で発行される Key ID
}
 
export function signPromotionalOffer(params: OfferParams) {
  const nonce = crypto.randomUUID();
  const timestamp = Math.floor(Date.now() / 1000);
 
  // 署名対象文字列の構築（順序が重要）
  const payload = [
    params.appBundleId,
    params.keyId,
    params.productId,
    params.offerId,
    params.applicationUsername,
    nonce,
    timestamp.toString(),
  ].join("⁣"); // U+2063 区切り
 
  const sign = createSign("SHA256");
  sign.update(payload);
  sign.end();
  const signature = sign.sign({
    key: params.privateKey,
    dsaEncoding: "der",
  });
 
  return {
    offerId: params.offerId,
    keyId: params.keyId,
    nonce,
    signature: signature.toString("base64"),
    timestamp,
  };
}

// Android 側: オファー適用
import com.android.billingclient.api.BillingClient
import com.android.billingclient.api.BillingFlowParams
import com.android.billingclient.api.QueryProductDetailsParams
 
suspend fun launchOfferFlow(
    activity: Activity,
    productId: String,
    offerToken: String
) {
    val productList = listOf(
        QueryProductDetailsParams.Product.newBuilder()
            .setProductId(productId)
            .setProductType(BillingClient.ProductType.SUBS)
            .build()
    )
 
    val params = QueryProductDetailsParams.newBuilder()
        .setProductList(productList)
        .build()
 
    val productDetailsResult = billingClient.queryProductDetails(params)
    val productDetails = productDetailsResult.productDetailsList?.firstOrNull() ?: return
 
    val productDetailsParamsList = listOf(
        BillingFlowParams.ProductDetailsParams.newBuilder()
            .setProductDetails(productDetails)
            .setOfferToken(offerToken) // サーバーから取得したオファートークン
            .build()
    )
 
    val billingFlowParams = BillingFlowParams.newBuilder()
        .setProductDetailsParamsList(productDetailsParamsList)
        .build()
 
    billingClient.launchBillingFlow(activity, billingFlowParams)
}

// src/lib/winback-offer-engine.ts
interface UserProfile {
  userId: string;
  cancelDate: Date;
  cancelReason?: "price" | "not_using" | "found_alternative" | "other";
  totalLifetimeRevenue: number;
  monthsActive: number;
  lastSessionDays: number;
}
 
interface OfferRecommendation {
  productId: string;
  offerId: string;
  channel: "push" | "email" | "in_app";
  message: string;
}
 
export function recommendWinbackOffer(profile: UserProfile): OfferRecommendation | null {
  const daysSinceCancel = Math.floor(
    (Date.now() - profile.cancelDate.getTime()) / (1000 * 60 * 60 * 24)
  );
 
  // タイミング: 解約から 7日 / 30日 / 90日でアプローチ
  if (![7, 30, 90].includes(daysSinceCancel)) return null;
 
  // 解約理由別のオファー
  switch (profile.cancelReason) {
    case "price":
      return {
        productId: "com.example.app.subscription.monthly",
        offerId: "winback_50_off_3months",
        channel: "push",
        message: "戻ってきてくれませんか？3か月50%オフでお試しいただけます。",
      };
 
    case "not_using":
      return {
        productId: "com.example.app.subscription.monthly",
        offerId: "winback_first_month_free",
        channel: "email",
        message: "最近のアップデートで使いやすくなりました。1か月無料でお試しください。",
      };
 
    case "found_alternative":
      // 競合に流れたユーザーには年間プラン提示で長期囲い込み
      return {
        productId: "com.example.app.subscription.yearly",
        offerId: "winback_yearly_30_off",
        channel: "in_app",
        message: "年間プランが30%オフでご利用いただけます。",
      };
 
    default:
      // LTV が高かったユーザーには手厚いオファー
      if (profile.totalLifetimeRevenue > 50) {
        return {
          productId: "com.example.app.subscription.yearly",
          offerId: "winback_loyal_50_off",
          channel: "push",
          message: "また一緒に過ごしたいです。年間プラン50%オフでお戻りください。",
        };
      }
      return null;
  }
}

// src/lib/push-notification-sender.ts
import { getMessaging } from "firebase-admin/messaging";
 
interface OfferNotification {
  userId: string;
  fcmToken: string;
  offerId: string;
  productId: string;
  message: string;
  deepLink: string; // アプリ内のオファー画面へのディープリンク
}
 
export async function sendOfferPushNotification(args: OfferNotification) {
  const messaging = getMessaging();
 
  await messaging.send({
    token: args.fcmToken,
    notification: {
      title: "特別なお知らせがあります",
      body: args.message,
    },
    data: {
      type: "winback_offer",
      offerId: args.offerId,
      productId: args.productId,
      deepLink: args.deepLink,
    },
    apns: {
      payload: {
        aps: {
          sound: "default",
          badge: 1,
          "mutable-content": 1,
        },
      },
    },
    android: {
      priority: "high",
      notification: {
        clickAction: "OPEN_OFFER",
      },
    },
  });
 
  // 配信ログを記録（A/Bテスト・効果分析のため）
  await logOfferDelivery({
    userId: args.userId,
    offerId: args.offerId,
    sentAt: new Date(),
  });
}

// iOS 側: 解約画面の前に理由を聞く
import SwiftUI
import StoreKit
 
struct CancellationFlowView: View {
    @State private var selectedReason: CancelReason?
    @State private var feedback: String = ""
 
    var body: some View {
        VStack(spacing: 16) {
            Text("解約の前に、お聞かせください")
                .font(.title2)
 
            Text("私たちのアプリのどこを改善できるか、教えていただけませんか？")
                .multilineTextAlignment(.center)
                .padding()
 
            ForEach(CancelReason.allCases) { reason in
                Button {
                    selectedReason = reason
                } label: {
                    HStack {
                        Image(systemName: selectedReason == reason ? "circle.fill" : "circle")
                        Text(reason.label)
                        Spacer()
                    }
                    .padding()
                }
            }
 
            TextEditor(text: $feedback)
                .frame(height: 100)
                .border(Color.gray.opacity(0.3))
 
            Button("送信して解約画面へ") {
                Task {
                    await submitCancellationReason(reason: selectedReason, feedback: feedback)
                    // 送信後、Apple の解約画面へ遷移
                    if let url = URL(string: "https://apps.apple.com/account/subscriptions") {
                        await UIApplication.shared.open(url)
                    }
                }
            }
        }
        .padding()
    }
}
 
enum CancelReason: String, CaseIterable, Identifiable {
    case tooExpensive = "price"
    case notUsing = "not_using"
    case foundAlternative = "found_alternative"
    case missingFeature = "missing_feature"
    case other = "other"
 
    var id: String { rawValue }
    var label: String {
        switch self {
        case .tooExpensive: return "料金が高い"
        case .notUsing: return "あまり使わなくなった"
        case .foundAlternative: return "他のサービスを使い始めた"
        case .missingFeature: return "欲しい機能がない"
        case .other: return "その他"
        }
    }
}

// src/lib/ab-test.ts
export function shouldShowOffer(userId: string, experimentId: string): boolean {
  // userId と experimentId のハッシュで安定的に振り分け
  const hash = simpleHash(`${userId}:${experimentId}`);
  return hash % 100 < 50; // 50% の確率で表示
}
 
interface ExperimentMetrics {
  experimentId: string;
  variant: "control" | "treatment";
  exposureCount: number;
  conversionCount: number;
  revenueGenerated: number;
}
 
export async function trackExposure(args: {
  userId: string;
  experimentId: string;
  variant: "control" | "treatment";
}) {
  await db.exposures.insert({
    userId: args.userId,
    experimentId: args.experimentId,
    variant: args.variant,
    exposedAt: new Date(),
  });
}
 
export async function trackConversion(args: {
  userId: string;
  experimentId: string;
  revenueAmount: number;
}) {
  // 直近 30日以内に exposure があった場合のみ conversion としてカウント
  const exposure = await db.exposures.findOne({
    userId: args.userId,
    experimentId: args.experimentId,
    exposedAt: { $gte: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000) },
  });
  if (!exposure) return;
 
  await db.conversions.insert({
    userId: args.userId,
    experimentId: args.experimentId,
    variant: exposure.variant,
    revenueAmount: args.revenueAmount,
    convertedAt: new Date(),
  });
}

// src/lib/email-winback-sender.ts
import { Resend } from "resend";
 
interface EmailWinbackArgs {
  userEmail: string;
  userName?: string;
  offerId: string;
  productId: string;
  discountPercent: number;
  appStoreUrl: string;
  unsubscribeUrl: string;
}
 
export async function sendEmailWinback(args: EmailWinbackArgs) {
  const resend = new Resend(process.env.RESEND_API_KEY!);
 
  const subject = `${args.userName ? args.userName + "さん、" : ""}特別なご提案があります`;
 
  await resend.emails.send({
    from: "Rork Max App <hello@example.com>",
    to: args.userEmail,
    subject,
    html: buildEmailHtml(args),
    text: buildEmailText(args),
    headers: {
      "List-Unsubscribe": `<${args.unsubscribeUrl}>`,
      "List-Unsubscribe-Post": "List-Unsubscribe=One-Click",
    },
  });
 
  await logEmailDelivery({
    userEmail: args.userEmail,
    offerId: args.offerId,
    sentAt: new Date(),
  });
}