Third-Party Market

Understanding

A payment-integration feature for servicing games on mobile markets (ONE Store) other than Google Play and the Apple App Store.
It supports unifying each market's payment system through the STOVE SDK's IAP interface for handling.

The basic payment flow is the same as Google (IAP) integration, and you apply it by declaring the per-market dedicated IAP module (iap-onestore) and adding Partners settings.
Other SDK features (authentication, log, push, etc.) can use the standard Android modules as-is.

Application Environment and Operating Scope

Integration Flow

Third-party market integration proceeds in 3 steps: Partners settings → apply the module → implement the SDK.

Register per-market info in Partners.

• Mobile market info: Package Name, billing key, App ID, etc.
• Per-market IAP info: the billing-integration ID and market authentication info
• Product-ID mapping: register the ONE Store product ID in the Market Product Management menu

Add the STOVE repository and the IAP module for the market you'll use to the game project's build.gradle.
When using ONE Store, also register the ONE Store SDK repository.

It's the same flow as Google (IAP) integration. The module handles per-market differences internally, so you don't need to write separate branching code.

1. Call initialize() — SDK initialization
2. Register setListener() — set up the payment-event listener
3. Handle the payment result — implement success/failure/cancellation branching

Integration Guide

Integration Preparation

Before third-party market integration, you must register the game in each market's developer console and issue the required authentication info.

ONE Store Setup

ONE Store integration is done in 3 Partners menus.
For ONE Store, additionally register the OAuth authentication info (Client ID, Secret, License Key).

In the Partners Mobile Market Info menu, select ONE Store as the market type and register the following items.

In the Partners Per-Market IAP Info Management menu, select ONE store as the market item and enter all 4 of the following items.

Enter product info in the Partners Market Product Management menu,
and map the product ID registered in ONE Store in the Market Product ID (ONE Store) column.

Development

ONE Store Implementation

For ONE Store payment, after applying the iap-onestore module, call in the order initialize → setListener. Payment results are delivered via the setListener callback, and for some error codes (RESULT_NEED_UPDATE / RESULT_NEED_LOGIN) the SDK automatically provides multilingual messages.

Prerequisites

• The Partners settings (mobile market info, per-market IAP info, market product-ID mapping) must be complete in the 2. Integration Guide section.
• The OAuth Client ID / Client Secret / License Key issued from the ONE Store console must be registered in Partners.
• The module applies only to Android builds. (iOS isn't a target)

Apply the module (build.gradle)

Register both the STOVE repository and the ONE Store SDK repository in build.gradle, and add the iap-onestore module dependency. Check the latest version in SDK Download and Installation.

repositories {
    google()
    jcenter()

    maven {
        url "https://externalnexus.iam0.com/repository/mvp" // for Stove
        // Add the option when using Android Gradle Plugin 7.0 or higher
        allowInsecureProtocol = true
    }

    mavenCentral() // for Facebook

    maven {
        url "https://repo.onestore.net/repository/onestore-sdk-public" // for OneStore
        allowInsecureProtocol = true
    }
}

dependencies {
    // Apply the latest version per the release notes.
    implementation 'com.stove:iap-onestore:2.8.0'
}

Development Flow

1. Create the OneStore object: create a OneStore(activity) instance with the Activity context.
2. Call initialize(): branch on the result in the initialization callback.
   • Success → call setListener()
   • Auth.UnauthorizedError (30002) → guide to the login screen
   • Other failures (InitializeError) → extract IAP.ResponseCodeKey / IAP.DebugMessageKey, then notify the user
3. Register setListener(): register the listener that receives payment results. Registering once while the game is active is enough.
4. Branch on the payment result: branch on the result.errorCode received in the callback and handle each case. (see the table below)

Payment-result branching

Note: flush() behavior

Because ONE Store provides an asynchronous unpaid-payment lookup function, the return value of flush() is always true. Unpaid-item handling works the same as existing IAP, so as long as you don't directly reference the return value of flush() as a branching condition, there's no impact on the game implementation.

Sample Code

private val iap: OneStore by lazy {
    OneStore(activity)
}

private fun initialize() {
    iap.initialize { result ->
        when {
            result.isSuccessful() -> {
                setListener() // call setListener
            }
            result.errorCode == Auth.UnauthorizedError -> {
                // TODO: login
            }
            else -> {
                // InitializeError
                val responseCode = result.userInfo!!.getValue(IAP.ResponseCodeKey)
                // RESULT_NEED_LOGIN / RESULT_NEED_UPDATE have multilingual messages applied
                val debugMessage = result.userInfo!!.getValue(IAP.DebugMessageKey)
            }
        }
    }
}

private fun setListener() {
    iap.setListener { result, product, purchaseDetail ->
        when {
            result.isSuccessful() -> {
                // Purchase succeeded
            }
            result.isCanceled() -> {
                // Purchase cancelled → show the screen again
            }
            result.isServerError() -> {
                // Billing-server error
            }
            result.errorCode == SuccessButUserMissMatch -> {
                // Mismatch between the payment-verification-time account and the current account — handle per the deliveryMethod policy
            }
            result.errorCode == Purchased -> {
                // Awaiting payment verification — guide to enable push
            }
            result.errorCode == Waiting -> {
                // Awaiting grant — guide to enable push
            }
            result.errorCode == MarketError -> {
                val responseCode = result.userInfo!!.getValue(IAP.ResponseCodeKey)
                val debugMessage = result.userInfo!!.getValue(IAP.DebugMessageKey)
            }
        }
    }
}

Frequently Asked Questions