Amazon Fire TVおよびFireタブレット対応のストリーミング／非ストリーミングアプリの収益化

<application>
…
  <receiver
      android:name="com.amazon.device.iap.ResponseReceiver"
      android:permission="com.amazon.inapp.purchasing.Permission.NOTIFY"
      android:exported="true">
    <intent-filter>
      <action android:name="com.amazon.inapp.purchasing.NOTIFY" />
    </intent-filter>
  </receiver>
</application>

override fun onCreate(savedInstanceState: Bundle?) {
  …
  myListener = MyPurchasingListener()
  …
}

…

override fun onResume() {
  super.onResume()
  PurchasingService.registerListener(this.applicationContext, myListener)
  PurchasingService.getUserData()
  PurchasingService.getPurchaseUpdates(false)
}

class MyPurchasingListener : PurchasingListener {

  override fun onUserDataResponse(response: UserDataResponse) {
    // [PurchasingService.getUserData] に応答して呼び出されます。
  }

  override fun onProductDataResponse(response: ProductDataResponse) {
    // [PurchasingService.getProductData] に応答して呼び出されます。
  }

  override fun onPurchaseResponse(response: PurchaseResponse) {
    // [PurchasingService.purchase] に応答して呼び出されます。
  }

  override fun onPurchaseUpdatesResponse(response: PurchaseUpdatesResponse)
  {
    // [PurchasingService.getPurchaseUpdates] に応答して呼び出されます。
  }

override fun onProductDataResponse(response: ProductDataResponse) {
  val requestStatus: ProductDataResponse.RequestStatus = response.requestStatus
  when (requestStatus) {
    ProductDataResponse.RequestStatus.SUCCESSFUL -> {
      Log.i(TAG, "ProductDataResponseが成功しました。")
      response.productData.forEach { sku, product ->
        Log.d(TAG, "商品： SKU：$sku、タイプ：${product.productType}、タイトル：${product.title}、説明：${product.description}、価格：${product.price}、SmallIconUrl：${product.smallIconUrl}")
        // 商品情報を使用してアプリのUIを更新します。
      }

      // リクエストされたSKUに利用できないものがないかチェックします。
      val unavailableSkus: Set<String> = response.unavailableSkus
      if (unavailableSkus.isNotEmpty()) {
        Log.w(TAG, "利用できないSKU：$unavailableSkus。これらのSKUは無効であるか、Amazon開発者コンソールで正しく公開されない可能性があります。")
      }
      
      // このデータに基づいて、購入可能な商品の購入ボタンを有効にします。
    }
    ProductDataResponse.RequestStatus.FAILED -> {
      Log.e(TAG, "ProductDataResponseが失敗しました。商品情報を取得できませんでした。")
    }
    ProductDataResponse.RequestStatus.NOT_SUPPORTED -> {
      Log.w(TAG, "ProductDataResponseはサポートされていません。IAPを利用できない可能性があります。")
    }
    else -> {
      Log.w(TAG, "ProductDataResponse： 未処理ステータス：$requestStatus")
    }
  }
}

override fun onPurchaseResponse(response: PurchaseResponse) {
    val requestStatus: PurchaseResponse.RequestStatus = response.requestStatus
    when (requestStatus) {
      PurchaseResponse.RequestStatus.SUCCESSFUL -> {
        val receipt: Receipt? = response.receipt
        if (receipt != null) {
          Log.i(TAG, "PurchaseResponseが成功しました。レシートID：${receipt.receiptId}、SKU：${receipt.sku}、購入日：${receipt.purchaseDate}、キャンセル日：${receipt.cancelDate}")

          // 重要： ここでサーバー側のレシート検証を実行します。

          // プレミアムコンテンツへのアクセスをユーザーに許可するためのロジックを実装します。
          Log.i(TAG, "SKU${receipt.sku}の購入が正常に完了しました。")

          if (receipt.isCanceled) {
            // このステートは、購入が（たとえばAmazonサポートによって）無効化されたことを示します。これは、正常に完了した新規の購入ではまれなケースです。
            Log.w(TAG, "onPurchaseResponseで購入がキャンセル済みとマークされました：${receipt.receiptId}。RVSでキャンセルが確認されたら、アクセス権を取り消す必要があります。")
            // プレミアムコンテンツへのアクセスを取り消すためのロジックを実装します。
          }
        } else {
          Log.e(TAG, "PurchaseResponseはSUCCESSFULですが、レシートがnullです。このような状況は改善が必要です。")
      }
    }
    PurchaseResponse.RequestStatus.FAILED -> {
      // 購入の試行に失敗しました（例：支払いの問題、ユーザーによるキャンセル）。
      Log.e(TAG, "PurchaseResponseが失敗しました。アクセス権は付与されません。")
      
      // 購入できなかったことをユーザーに伝えます。
      // オプションとして、理由または対処方法を表示します。
    }
    PurchaseResponse.RequestStatus.ALREADY_PURCHASED -> {
      // このステータスは、ユーザーがこのアクティブな定期購入型アイテムを既に持っていることを意味します。
      // これは必ずしもエラーであるとは限りません。
      // ユーザーがコンテンツにアクセスできることを確認します。
      Log.i(TAG, "PurchaseResponse： SKU${response.receipt?.sku}は購入済みです。")

      // 定期購入型アイテムがアクティブであることを確認します。
      // ローカルキャッシュの確認や、getPurchaseUpdatesまたはレシート検証サービスでの再検証が必要な場合もあります。

      // 必要に応じてUIを更新し、ステータスを反映させます。
    }
    PurchaseResponse.RequestStatus.INVALID_SKU -> {
      // 購入の呼び出しで示されたSKUが無効であるか、Amazonで認識できません。
      Log.e(TAG, "PurchaseResponse： SKUが無効です。SKU：${response.receipt?.sku}。Amazon開発者コンソールでのSKUの定義とアプリのコードを確認してください。")
    }
    PurchaseResponse.RequestStatus.NOT_SUPPORTED -> {
      // この購入操作はサポートされていません。
      Log.w(TAG, "PurchaseResponseはサポートされていません。IAPを利用できない可能性があります。")
    }
    else -> {
      Log.w(TAG, "PurchaseResponse： 未処理ステータス：$requestStatus")
    }
  }
}

https://appstore-sdk.amazon.com/version/1.0/verifyReceiptId/developer/REPLACE-WITH-SHARED-SECRET/user/REPLACE-WITH-USER-ID/receiptID/REPLACE-WITH-RECEIPT_ID

fun fetchSubscriptionProductData() {
  Log.d(TAG, "定期購入型アイテムの商品データを取得します。")
  val subscriptionSkus: MutableSet<String> = HashSet()
  subscriptionSkus.add("subscription_mo_ptp_01")
  subscriptionSkus.add("subscription_yr_ptp_02")
  PurchasingService.getProductData(subscriptionSkus)
}

fun initiatePurchase(sku: String) {
  if (sku.isBlank()) {
    Log.e(TAG, "SKUを空白にして購入を開始することはできません。")
    return
  }
  Log.d(TAG, "SKU: $skuの購入を開始しようとしています")
  PurchasingService.purchase(sku)

private fun fulfillConsumable(receipt: Receipt) {
  val sku: String = receipt.sku
  val receiptId: String = receipt.receiptId

  Log.i(TAG, "SKU$skuの付与をレシートID$receiptIdで試行しています")
  // 概念的には、ここでユーザーにアイテムを提供します。
  // たとえば、ヒントやライフなどの数を増やします。
 
  // アイテムの付与が完了したことをAmazonに通知します。
  PurchasingService
    .notifyFulfillment(receiptId, FulfillmentResult.FULFILLED)
  Log.i(TAG, "FULFILLEDとマークされたレシートID$receiptIdのnotifyFulfillmentを呼び出しました")
}

override fun onPurchaseResponse(response: PurchaseResponse) {
  val skuFromReceipt: String = response.receipt?.sku ?: "N/A"

  when (response.requestStatus) {
    PurchaseResponse.RequestStatus.SUCCESSFUL -> {
      response.receipt?.let { currentReceipt ->
        val successMsg: String = "SKUの購入ステータスはSUCCESSFULです：${currentReceipt.sku}。ReceiptId：${currentReceipt.receiptId}"
        if (currentReceipt.productType == ProductType.CONSUMABLE) {
          fulfillConsumable(currentReceipt)
        } else {
          // 別のタイプのIAPを処理します。
        }
      } ?: run {
        val errorMsg: String = "購入ステータスはSUCCESSFULですが、レシートがnullです。このような状況は改善が必要です。"
        Log.e(TAG, errorMsg)
      }
    }
    PurchaseResponse.RequestStatus.FAILED -> {
      val failedMsg: String = "SKUの購入ステータスはFAILEDです：$skuFromReceipt。ログを確認してください。"
      Log.e(TAG, failedMsg)
    }
    PurchaseResponse.RequestStatus.ALREADY_PURCHASED -> {
      val alreadyPurchasedMsg: String = "SKUの購入ステータスはALREADY_PURCHASEDです：$skuFromReceipt。"
      Log.w(TAG, alreadyPurchasedMsg)
      response.receipt?.let { currentReceipt ->
        if (currentReceipt.productType == ProductType.CONSUMABLE) {
          fulfillConsumable(currentReceipt)
        }
      }
    }
    PurchaseResponse.RequestStatus.INVALID_SKU -> {
      val invalidSkuMsg: String = "購入ステータスはINVALID_SKUです：$skuFromReceipt。開発者コンソールでSKUを確認してください。"
      Log.w(TAG, invalidSkuMsg)
    }
    PurchaseResponse.RequestStatus.NOT_SUPPORTED -> {
      val notSupportedMsg: String = "購入ステータスはNOT_SUPPORTEDです。デバイスの機能またはIAPの設定を確認してください。"
      Log.w(TAG, notSupportedMsg)
    }
    PurchaseResponse.RequestStatus.PENDING -> {
      val pendingMsg: String = "SKUの購入ステータスはPENDINGです：$skuFromReceipt.解決（親の承認など）を待っています。"
      Log.i(TAG, pendingMsg)
      // 通常、ここではアプリはアクションを実行しません。Amazon
      // アプリストアが保留中の状態を処理し
      // 新しいonPurchaseResponseまたはonPurchaseUpdatesResponseが 
      // 解決時に送信されます。
    }
    null -> {
      val nullMsg: String = "PurchaseResponseのステータスはNULL（または未処理）です。このような状況は改善が必要です。"
      Log.e(TAG, nullMsg)
    }
  }
}

import com.chartboost.sdk.Chartboost
import com.chartboost.sdk.ads.Rewarded
import com.chartboost.sdk.LoggingLevel
import com.chartboost.sdk.events.*
import com.chartboost.sdk.callbacks.RewardedCallback
import com.chartboost.sdk.privacy.model.DataUseConsent

// 実際のChartboostアプリIDとアプリ署名に置き換えます。
private val chartboostAppID: String = "CHARTBOOST_APP_ID"
private val chartboostAppSignature: String = "CHARTBOOST_APP_SIGNATURE"

// リワード広告のデフォルトの位置を定義します。
const val REWARDED_AD_LOCATION = "default-rewarded_video"

…

override fun onCreate(savedInstanceState: Bundle?) {
  …

  // SDKを初期化する前にデータの使用許諾を設定することが重要です。
  // 実際のアプリでは、これはユーザーの同意に基づきます。
  // この例では、プレースホルダーを使用します。
  Chartboost.addDataUseConsent(this, DataUseConsent.GDPR("1"))
  Chartboost.addDataUseConsent(this, DataUseConsent.CCPA("1---"))

  // 詳細ログを有効にします。startWithAppIdの前にこれを呼び出します。
  Chartboost.setLoggingLevel(LoggingLevel.ALL)

  Chartboost.startWithAppId(
    applicationContext, chartboostAppID, chartboostAppSignature
  ) { startError ->
        if (startError == null) {
          val message = "Chartboost SDKが正常に初期化されました。"
          Log.d("ChartboostInit", message)
          // 初期化が正常に完了したら、広告をプリキャッシュします。
          loadRewardedAd()
        } else {
          val errorMessage = "Chartboost SDKの初期化に失敗しました：${startError.code.name}"
          Log.e("ChartboostInit", errorMessage)
        }
   }
}
…

private fun loadRewardedAd() {
  if (rewardedAd == null || !rewardedAd!!.isCached()) {
    createAndCacheRewardedAd()
  } else {
    Log.d("ChartboostRewarded", "$REWARDED_AD_LOCATIONのリワード広告は既にキャッシュされています。")
    showAdButton.isEnabled = true
  }
}

private fun createAndCacheRewardedAd() {
  rewardedAd = Rewarded(REWARDED_AD_LOCATION, object : RewardedCallback {
  
    override fun onAdLoaded(event: CacheEvent, error: CacheError?) {
      if (error != null) {
        val errorMessage = "位置${event.ad.location}のリワード広告の読み込みに失敗しました：${error.code.name}"
        Log.e("ChartboostRewarded", errorMessage)
        showAdButton.isEnabled = false
      } else {
        Log.d("ChartboostRewarded", "位置${event.ad.location}のリワード広告の読み込みが正常に完了しました。")
        showAdButton.isEnabled = true
      }
    }

    override fun onAdRequestedToShow(event: ShowEvent) {
      Log.d("ChartboostRewarded", "${event.ad.location}の位置のリワード広告の表示が要求されました。")
    }

    override fun onAdShown(event: ShowEvent, error: ShowError?) {
      if (error != null) {
        Log.e("ChartboostRewarded", "位置${event.ad.location}のリワード広告の表示に失敗しました：${error.code.name}")
      } else {
        Log.d("ChartboostRewarded", "位置${event.ad.location}リワード広告が正常に表示されました。")
      }
    }

    override fun onAdClicked(event: ClickEvent, error: ClickError?) {
      val message = if (error == null) {
        "位置${event.ad.location}のリワード広告がクリックされました。"
      } else {
        "位置${event.ad.location}のリワード広告のクリックエラー：${error.code.name}"
      }
      Log.d("ChartboostRewarded", message)
    }

    override fun onAdDismiss(event: DismissEvent) {
      Log.d("ChartboostRewarded", "位置${event.ad.location}のリワード広告が閉じられました。")
      showAdButton.isEnabled = false
      
      // 広告が閉じられた後で次の広告をキャッシュすることをお勧めします。
      loadRewardedAd()
    }

    override fun onRewardEarned(event: RewardEvent) {
      Log.d("ChartboostRewarded", "ユーザーが位置${event.ad.location}の広告を見てリワード${event.reward}を獲得しました。")

      // ここでユーザーにリワード （例：コイン10個）を付与します。
      // val currentCoins = sharedPreferences.getInt("user_coins", 0)
      // sharedPreferences.edit().putInt("user_coins", currentCoins + event.reward).apply()
      // updateUiWithNewCoinBalance(currentCoins + event.reward)
      // Log.d("ChartboostRewarded", "ユーザーに${event.reward}のコインが付与されました。現在のコイン残高：${currentCoins + event.reward}")
     

    }

    override fun onImpressionRecorded(event: ImpressionEvent) {
      Log.d("ChartboostRewarded", "位置${event.ad.location}のリワード広告のインプレッションが記録されました。")
    }
  }, null)

  rewardedAd?.cache()
}

private fun showRewardedAd() {
  if (rewardedAd != null && rewardedAd!!.isCached()) {
    rewardedAd?.show()
  } else {
    Log.w("ChartboostRewarded", "$REWARDED_AD_LOCATIONに広告を表示しようとしましたが、キャッシュされていません。")
    showAdButton.isEnabled = false
    
    // 表示されない場合、読み込みを試みます。
    loadRewardedAd()
  }
}

nterstitialAd = Interstitial("location", object : InterstitialCallback {

  override fun onAdDismiss(dismissEvent: DismissEvent) {
    // 広告が閉じられると呼び出されます。
    // リクエストされた動画を再生せずに、動画ギャラリーにユーザーを戻します。
  }

  override fun onAdLoaded(cacheEvent: CacheEvent, cacheError: CacheError) {
    // 広告がChartboostサーバーから読み込まれてキャッシュされました。
    // CacheErrorがない場合、広告は表示できる状態です。
  }

  override fun onAdRequestedToShow(showEvent: ShowEvent) {
    // 広告が表示される直前に呼び出されます。
  }

  override fun onAdShown(showEvent: ShowEvent, showError: ShowError?) {
    // 広告が表示されるかインプレッションが記録されたら呼び出されます。
    // ユーザーからリクエストされた動画の再生に進みます。
  }

  override fun onAdClicked(clickEvent: ClickEvent, clickError: ClickError?)
  {
    // 広告がクリックされたら呼び出されます。
    // 発生時にキャプチャ（記録、通知）したい場合に使用します。
  }

  override fun onImpressionRecorded(impressionEvent: ImpressionEvent) {
    // 広告がインプレッションを記録したら呼び出されます。
    // 発生時にキャプチャ（記録、通知）したい場合に使用します。
  }

}, null)

interstitialAd.cache()

if (interstitialAd.isCached()) {
  interstitialAd.show()
}