Javasteam wishlist demo

app/build.gradle.kts

@@ -331,8 +331,8 @@ dependencies {
     // JavaSteam
     val localBuild = false // Change to 'true' needed when building JavaSteam manually
     if (localBuild) {
-        implementation(files("../../JavaSteam/build/libs/javasteam-1.8.0.1-22-SNAPSHOT.jar"))
-        implementation(files("../../JavaSteam/javasteam-depotdownloader/build/libs/javasteam-depotdownloader-1.8.0.1-22-SNAPSHOT.jar"))
+        implementation(files("../../JavaSteam/build/libs/javasteam-1.8.0.1-25-SNAPSHOT.jar"))
+        implementation(files("../../JavaSteam/javasteam-depotdownloader/build/libs/javasteam-depotdownloader-1.8.0.1-25-SNAPSHOT.jar"))
         implementation(libs.bundles.javasteam.dev)
     } else {
         implementation(libs.javasteam) {

app/src/main/java/app/gamenative/data/Featured.kt

@@ -15,6 +15,7 @@ data class HeroResponse(
 data class FeaturedItem(
     val campaignId: String,
     val title: String,
+    val appId: Int? = null,
     val developer: String? = null,
     val heroImageUrl: String = "",
     val capsuleImageUrl: String? = null,
@@ -34,6 +35,7 @@ data class FeaturedItem(
 data class FeaturedAction(
     val type: String,
     val url: String,
+    val appId: Int? = null,
     val store: String? = null,
     val style: String? = null,
     // Only for type CUSTOM: advertiser-supplied locale -> label map.
@@ -61,6 +63,7 @@ fun FeaturedAction.localizedLabel(context: Context): String = when (type.upperca
     "BUY" -> store?.let { context.getString(R.string.featured_action_buy_on, it) }
         ?: context.getString(R.string.featured_action_buy)
     "NOTIFY" -> context.getString(R.string.featured_action_notify)
+    "GET_DEMO" -> context.getString(R.string.featured_action_get_demo)
     "VISIT" -> context.getString(R.string.featured_action_visit)
     else -> label.forLocale(context) ?: context.getString(R.string.featured_action_visit)
 }
@@ -91,6 +94,8 @@ fun FeaturedItem.toRecommendedGame(context: Context): RecommendedGame = Recommen
             label = a.localizedLabel(context),
             url = a.url,
             primary = a.style?.equals("primary", ignoreCase = true) ?: (index == 0),
+            type = a.type.uppercase(),
+            appId = a.appId ?: appId,
         )
     },
 )

app/src/main/java/app/gamenative/data/RecommendationRepository.kt

@@ -17,6 +17,37 @@ object RecommendationRepository {
     private const val API_URL = "https://api.gamenative.app/api/games/hero"
     private const val CACHE_TTL_MS = 24L * 60L * 60L * 1000L
 
+    private const val MOCK_HERO_RESPONSE = false
+
+    internal val MOCK_HERO_JSON = """
+        {
+          "recommendation": null,
+          "featured": {
+            "campaignId": "mock-whisk",
+            "title": "Whisk",
+            "appId": 3602270,
+            "developer": "Double Dusk Inc.",
+            "heroImageUrl": "https://shared.akamai.steamstatic.com/store_item_assets/steam/apps/3602270/92fb97a2832c9c075165c43d14d974c730ca716b/library_hero.jpg",
+            "capsuleImageUrl": "https://shared.akamai.steamstatic.com/store_item_assets/steam/apps/3602270/435512f90bdf39498f17fcbd103b19fa1223a430/library_capsule.jpg",
+            "screenshots": [
+              "https://shared.akamai.steamstatic.com/store_item_assets/steam/apps/3602270/e0a52a09cd85472aecfb430ad086aae040cb100c/ss_e0a52a09cd85472aecfb430ad086aae040cb100c.1920x1080.jpg",
+              "https://shared.akamai.steamstatic.com/store_item_assets/steam/apps/3602270/77719570b08d1b46facf8477df20aa5b97b54573/ss_77719570b08d1b46facf8477df20aa5b97b54573.1920x1080.jpg",
+              "https://shared.akamai.steamstatic.com/store_item_assets/steam/apps/3602270/08fd286888a7efb1e782a5106fdb1b1f237bcdb2/ss_08fd286888a7efb1e782a5106fdb1b1f237bcdb2.1920x1080.jpg"
+            ],
+            "tags": ["Action", "Indie"],
+            "status": "COMING_SOON",
+            "description": {
+              "en": "Whisk is a two-player platformer about shared movement and communication. Coordinate jumps, climbs and throws with a partner to get every Dreamcat home."
+            },
+            "actions": [
+              { "type": "WISHLIST", "url": "https://store.steampowered.com/app/3602270/", "store": "Steam", "style": "primary" },
+              { "type": "GET_DEMO", "url": "https://store.steampowered.com/app/3602270/", "appId": 4320000 },
+              { "type": "VISIT", "url": "https://store.steampowered.com/app/3602270/" }
+            ]
+          }
+        }
+    """.trimIndent()
+
     private val json = Json { ignoreUnknownKeys = true }
 
     // Latest featured from the most recent fetch. Kept in memory (not the disk cache) so the
@@ -30,7 +61,7 @@ object RecommendationRepository {
      */
     suspend fun getHero(context: Context): HeroResponse =
         withContext(Dispatchers.IO) {
-            val fetched = fetchRemote()
+            val fetched = if (MOCK_HERO_RESPONSE) parseHero(MOCK_HERO_JSON) else fetchRemote()
             if (fetched != null) {
                 lastFeatured = fetched.featured
                 return@withContext HeroResponse(

app/src/main/java/app/gamenative/data/RecommendedGame.kt

@@ -33,4 +33,6 @@ data class FeaturedCta(
     val label: String,
     val url: String,
     val primary: Boolean = false,
+    val type: String = "",
+    val appId: Int? = null,
 )

app/src/main/java/app/gamenative/service/SteamService.kt

@@ -727,6 +727,24 @@ class SteamService : Service(), IChallengeUrlChanged {
             }.orEmpty()
         }
 
+        suspend fun isAppInLibrary(appId: Int): Boolean =
+            instance?.licenseDao?.getAllLicenses()?.any { appId in it.appIds } == true
+
+        suspend fun requestFreeLicense(appId: Int): Boolean = withContext(Dispatchers.IO) {
+            val steamApps = instance?._steamApps ?: return@withContext false
+            try {
+                val callback = steamApps.requestFreeLicense(appId).toFuture().await()
+                Timber.i(
+                    "requestFreeLicense($appId) -> ${callback.result}, " +
+                        "apps=${callback.grantedApps}, packages=${callback.grantedPackages}",
+                )
+                callback.result == EResult.OK && appId in callback.grantedApps
+            } catch (e: Exception) {
+                Timber.e(e, "requestFreeLicense($appId) failed")
+                false
+            }
+        }
+
         suspend fun getOwnedAppDlc(appId: Int): Map<Int, DepotInfo> {
             val client = instance?.steamClient ?: return emptyMap()
             val accountId = client.steamID?.accountID?.toInt() ?: return emptyMap()

app/src/main/java/app/gamenative/service/SteamWishlistService.kt

@@ -0,0 +1,97 @@
+package app.gamenative.service
+
+import app.gamenative.utils.Net
+import `in`.dragonbra.javasteam.enums.EResult
+import `in`.dragonbra.javasteam.protobufs.steamclient.SteammessagesWishlistSteamclient.CWishlist_AddToWishlist_Request
+import `in`.dragonbra.javasteam.protobufs.steamclient.SteammessagesWishlistSteamclient.CWishlist_RemoveFromWishlist_Request
+import `in`.dragonbra.javasteam.rpc.service.Wishlist
+import `in`.dragonbra.javasteam.steam.handlers.steamunifiedmessages.SteamUnifiedMessages
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.future.await
+import kotlinx.coroutines.withContext
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import okhttp3.Request
+import org.json.JSONObject
+import timber.log.Timber
+
+object SteamWishlistService {
+
+    private const val TAG = "SteamWishlist"
+    private const val JOB_TIMEOUT_MS = 15_000L
+    private const val GET_URL = "https://api.steampowered.com/IWishlistService/GetWishlist/v1/"
+
+    sealed interface Outcome {
+        data object Success : Outcome
+        data object NoSession : Outcome
+        data class Failed(val result: EResult?) : Outcome
+    }
+
+    suspend fun addToWishlist(appId: Int): Outcome = withContext(Dispatchers.IO) {
+        val service = service() ?: return@withContext Outcome.NoSession
+        val request = CWishlist_AddToWishlist_Request.newBuilder().setAppid(appId).build()
+        runJob("AddToWishlist") {
+            service.addToWishlist(request).also { it.timeout = JOB_TIMEOUT_MS }.toFuture().await().result
+        }
+    }
+
+    suspend fun removeFromWishlist(appId: Int): Outcome = withContext(Dispatchers.IO) {
+        val service = service() ?: return@withContext Outcome.NoSession
+        val request = CWishlist_RemoveFromWishlist_Request.newBuilder().setAppid(appId).build()
+        runJob("RemoveFromWishlist") {
+            service.removeFromWishlist(request).also { it.timeout = JOB_TIMEOUT_MS }.toFuture().await().result
+        }
+    }
+
+    suspend fun isWishlisted(appId: Int): Boolean? = withContext(Dispatchers.IO) {
+        val steamId = SteamService.userSteamId?.convertToUInt64()
+        if (steamId == null || steamId == 0L) {
+            Timber.tag(TAG).w("no live steam session, cannot read wishlist")
+            return@withContext null
+        }
+        val url = GET_URL.toHttpUrl().newBuilder()
+            .addQueryParameter("steamid", steamId.toString())
+            .build()
+        try {
+            Net.http.newCall(Request.Builder().url(url).build()).execute().use { res ->
+                if (!res.isSuccessful) {
+                    Timber.tag(TAG).w("wishlist read failed ${res.code}")
+                    return@use null
+                }
+                val response = JSONObject(res.body?.string().orEmpty()).optJSONObject("response")
+                val items = response?.optJSONArray("items") ?: return@use null
+                (0 until items.length()).any { items.optJSONObject(it)?.optInt("appid") == appId }
+            }
+        } catch (e: Exception) {
+            Timber.tag(TAG).e(e, "wishlist read failed")
+            null
+        }
+    }
+
+    private fun service(): Wishlist? {
+        val client = SteamService.instance?.steamClient
+        if (client == null) {
+            Timber.tag(TAG).w("no steam client")
+            return null
+        }
+        val unifiedMessages = client.getHandler<SteamUnifiedMessages>()
+        if (unifiedMessages == null) {
+            Timber.tag(TAG).e("SteamUnifiedMessages handler not available")
+            return null
+        }
+        return try {
+            unifiedMessages.createService(Wishlist::class.java)
+        } catch (t: Throwable) {
+            Timber.tag(TAG).e(t, "cannot create Wishlist service")
+            null
+        }
+    }
+
+    private suspend fun runJob(method: String, block: suspend () -> EResult?): Outcome = try {
+        val result = block()
+        Timber.tag(TAG).i("$method -> $result")
+        if (result == EResult.OK) Outcome.Success else Outcome.Failed(result)
+    } catch (e: Exception) {
+        Timber.tag(TAG).e(e, "$method failed")
+        Outcome.Failed(null)
+    }
+}

app/src/main/java/app/gamenative/ui/screen/library/FeaturedCtaButton.kt

@@ -0,0 +1,167 @@
+package app.gamenative.ui.screen.library
+
+import android.content.Intent
+import androidx.annotation.StringRes
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Button
+import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.core.net.toUri
+import app.gamenative.PrefManager
+import app.gamenative.R
+import app.gamenative.data.FeaturedCta
+import app.gamenative.service.SteamService
+import app.gamenative.service.SteamWishlistService
+import app.gamenative.ui.component.focusRing
+import app.gamenative.ui.util.SnackbarManager
+import app.gamenative.utils.ConversionTracker
+import com.posthog.PostHog
+import kotlinx.coroutines.launch
+
+@Composable
+internal fun FeaturedCtaButton(
+    action: FeaturedCta,
+    campaignId: String,
+    recSource: String,
+    focusRequester: FocusRequester? = null,
+) {
+    val context = LocalContext.current
+    val scope = rememberCoroutineScope()
+    val interactionSource = remember { MutableInteractionSource() }
+    val cta = remember(action) { InAppCta.forAction(action) }
+    var done by remember(action) { mutableStateOf<Boolean?>(null) }
+    var busy by remember(action) { mutableStateOf(false) }
+
+    LaunchedEffect(action) {
+        if (cta != null) {
+            done = cta.isDone()
+        }
+    }
+
+    val openUrl = { context.startActivity(Intent(Intent.ACTION_VIEW, action.url.toUri())) }
+
+    val inert = cta != null && (busy || done == true)
+
+    val onClick: () -> Unit = onClick@{
+        if (inert) return@onClick
+
+        if (PrefManager.usageAnalyticsEnabled) {
+            PostHog.capture(
+                event = "featured_action_clicked",
+                properties = mapOf(
+                    "campaign_id" to campaignId,
+                    "action_label" to action.label,
+                    "url" to action.url,
+                    "source" to recSource,
+                ),
+            )
+        }
+        if (cta == null) {
+            openUrl()
+        } else {
+            busy = true
+            scope.launch {
+                val ok = cta.run()
+                busy = false
+                if (ok) {
+                    done = true
+                    ConversionTracker.featuredConversion(
+                        campaignId = campaignId,
+                        actionType = action.type,
+                        appId = action.appId,
+                        source = recSource,
+                    )
+                } else {
+                    SnackbarManager.show(context.getString(R.string.featured_action_failed))
+                    openUrl()
+                }
+            }
+        }
+    }
+
+    val label = if (cta != null && done == true) stringResource(cta.doneLabelRes) else action.label
+    val shape = RoundedCornerShape(12.dp)
+    val buttonModifier = Modifier
+        .fillMaxWidth()
+        .focusRing(interactionSource, shape, width = 2.dp)
+        .let { if (focusRequester != null) it.focusRequester(focusRequester) else it }
+
+    val contentAlpha = if (inert) 0.6f else 1f
+
+    if (action.primary) {
+        Button(
+            onClick = onClick,
+            modifier = buttonModifier,
+            shape = shape,
+            interactionSource = interactionSource,
+            colors = ButtonDefaults.buttonColors(
+                containerColor = MaterialTheme.colorScheme.primary.copy(alpha = contentAlpha),
+            ),
+        ) {
+            Text(text = label, fontWeight = FontWeight.SemiBold)
+        }
+    } else {
+        OutlinedButton(
+            onClick = onClick,
+            modifier = buttonModifier,
+            shape = shape,
+            interactionSource = interactionSource,
+            colors = ButtonDefaults.outlinedButtonColors(
+                contentColor = MaterialTheme.colorScheme.primary.copy(alpha = contentAlpha),
+            ),
+        ) {
+            Text(text = label, fontWeight = FontWeight.SemiBold)
+        }
+    }
+}
+
+private sealed class InAppCta(
+    val appId: Int,
+    @StringRes val doneLabelRes: Int,
+) {
+    abstract suspend fun isDone(): Boolean?
+
+    abstract suspend fun run(): Boolean
+
+    private class Wishlist(appId: Int) : InAppCta(appId, R.string.featured_action_wishlisted) {
+        override suspend fun isDone(): Boolean? = SteamWishlistService.isWishlisted(appId)
+
+        override suspend fun run(): Boolean =
+            SteamWishlistService.addToWishlist(appId) is SteamWishlistService.Outcome.Success
+    }
+
+    private class GetDemo(appId: Int) : InAppCta(appId, R.string.featured_action_in_library) {
+        override suspend fun isDone(): Boolean = SteamService.isAppInLibrary(appId)
+
+        override suspend fun run(): Boolean = SteamService.requestFreeLicense(appId)
+    }
+
+    companion object {
+        fun forAction(action: FeaturedCta): InAppCta? {
+            val appId = action.appId ?: return null
+            return when (action.type) {
+                "WISHLIST" -> Wishlist(appId)
+                "GET_DEMO" -> GetDemo(appId)
+                else -> null
+            }
+        }
+    }
+}