Shoplive V1 Mobile SDK Integration Guide

// settings.gradle (dependencyResolutionManagement) or the project build.gradle
repositories {
    maven { url 'https://sdk.shoplive.cloud/maven-repo' }
    google()
    mavenCentral()
}

// app/build.gradle
dependencies {
    def shoplive_sdk_version = "1.9.0"

    implementation "cloud.shoplive:shoplive-sdk-core:$shoplive_sdk_version"
    implementation "cloud.shoplive:shoplive-common:$shoplive_sdk_version"
    implementation "cloud.shoplive:shoplive-network:$shoplive_sdk_version"
    implementation "cloud.shoplive:shoplive-exoplayer:2.19.1.20"
    // To use Media3 instead of ExoPlayer:
    // implementation "cloud.shoplive:shoplive-media3:1.10.1.3"
}

ShopLive.setHandler(object : ShopLiveHandler() {
    override fun handleNavigation(context: Context, url: String) {
        // Handle link navigation
    }
})

flutter pub add 'shoplive_player:^1.9.0'

# pubspec.yaml
dependencies:
  shoplive_player: ^1.9.0

# ios/Podfile (top)
source 'https://github.com/shoplive/pod-specs.git'
source 'https://cdn.cocoapods.org/'
platform :ios, '15.0'

cd ios && pod install --repo-update

// android/build.gradle(.kts)
allprojects {
    repositories {
        google()
        mavenCentral()
        maven { url = uri("https://sdk.shoplive.cloud/maven-repo") }
    }
}

import 'package:shoplive_player/shoplive_player.dart';
import 'package:shoplive_player/shoplive_common.dart';

import ShopliveSDKCommon
import ShopLiveSDK

// 1) Once, at app launch
ShopLiveCommon.setAccessKey(accessKey: "YOUR_ACCESS_KEY")

// 2) Enter viewing
ShopLive.play(data: .init(campaignKey: "YOUR_CAMPAIGN_KEY"))

// 1) Once, at app launch
ShopLive.setAccessKey("YOUR_ACCESS_KEY")
ShopLive.setHandler(myHandler)

// 2) Enter viewing
ShopLive.play(this, ShopLivePlayerData("YOUR_CAMPAIGN_KEY"))

final common = ShopLiveCommon();
final player = ShopLivePlayer();

// 1) Once, at app launch
common.setAccessKey(accessKey: 'YOUR_ACCESS_KEY');

// 2) Enter viewing
player.play(data: ShopLivePlayerData(campaignKey: 'YOUR_CAMPAIGN_KEY'));

git clone https://github.com/shoplive/shoplive-sdk-flutter.git
cd shoplive-sdk-flutter && git checkout 1.9.0
cd shoplive_flutter_sample/example && flutter pub get && flutter run

import ShopliveSDKCommon
import ShopLiveSDK

ShopLiveCommon.setAccessKey(accessKey: "{ACCESS_KEY}")
ShopLive.play(data: .init(campaignKey: "{CAMPAIGN_KEY}"))

ShopLive.setAccessKey(accessKey)
ShopLive.play(this, ShopLivePlayerData(campaignKey).apply {
    keepWindowStateOnPlayExecuted = false
    referrer = "referrer"
})

final common = ShopLiveCommon();
final player = ShopLivePlayer();

common.setAccessKey(accessKey: "{ACCESS_KEY}");
player.play(data: ShopLivePlayerData(campaignKey: "{CAMPAIGN_KEY}"));

let previewData = ShopLivePreviewData(
    campaignKey: "{CAMPAIGN_KEY}",
    isMuted: true,
    resolution: .PREVIEW
)

ShopLive.preview(data: previewData) {
    // Call play here if you want the tap on the preview to switch to full playback
    ShopLive.play(data: .init(campaignKey: "{CAMPAIGN_KEY}"))
}

ShopLive.showPreviewPopup(this@YourActivity, ShopLivePreviewData(campaignKey))

// 1) Set the options first
player.setPreviewOption(
  data: ShopLivePlayerPreviewData(
    campaignKey: "{CAMPAIGN_KEY}",
    useCloseButton: true,
    enableSwipeOut: true,
    position: "BOTTOM_RIGHT",
  ),
);

// 2) Then show it (use hidePreview to hide)
player.showPreview(campaignKey: "{CAMPAIGN_KEY}");

<!-- AndroidManifest.xml -->
<activity
    android:name=".SchemeActivity"
    android:exported="true"
    android:noHistory="true"
    android:screenOrientation="portrait">
    <intent-filter android:autoVerify="true">
        <action android:name="android.intent.action.VIEW" />

        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />

        <data
            android:scheme="https"
            android:host="xxxx"
            android:path="/yyyy" />
    </intent-filter>
</activity>

<intent-filter>
    <action android:name="android.intent.action.VIEW" />

    <category android:name="android.intent.category.DEFAULT" />
    <category android:name="android.intent.category.BROWSABLE" />

    <data
        android:scheme="shoplive"
        android:host="live" />
</intent-filter>

// SceneDelegate
func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
    guard let url = URLContexts.first?.url,
          let components = URLComponents(url: url, resolvingAgainstBaseURL: false),
          let queryItems = components.queryItems else { return }

    var campaignKey: String? = nil

    for item in queryItems {
        let value = item.value ?? ""
        switch item.name {
        case "ak":           ShopLiveCommon.setAccessKey(accessKey: value)
        case "ck":           campaignKey = value
        case "utm_source":   ShopLiveCommon.setUtmSource(utmSource: value)
        case "utm_medium":   ShopLiveCommon.setUtmMedium(utmMedium: value)
        case "utm_campaign": ShopLiveCommon.setUtmCampaign(utmCampaign: value)
        case "utm_content":  ShopLiveCommon.setUtmContent(utmContent: value)
        default:             ShopLive.addParameter(key: item.name, value: value)
        }
    }

    guard let campaignKey = campaignKey else { return }
    ShopLive.play(data: .init(campaignKey: campaignKey))
}

class SchemeActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        handle(intent)
    }

    override fun onNewIntent(intent: Intent?) {
        super.onNewIntent(intent)
        handle(intent)
    }

    private fun handle(intent: Intent?) {
        val uri = intent?.data
        if (uri == null) {
            finish()
            return
        }

        var campaignKey: String? = null

        for (name in uri.queryParameterNames) {
            val value = uri.getQueryParameter(name) ?: continue
            when (name) {
                "ak" -> ShopLiveCommon.setAccessKey(value)
                "ck" -> campaignKey = value
                "utm_source" -> ShopLive.setUtmSource(value)
                "utm_medium" -> ShopLive.setUtmMedium(value)
                "utm_campaign" -> ShopLive.setUtmCampaign(value)
                "utm_content" -> ShopLive.setUtmContent(value)
                else -> ShopLive.addParameter(name, value)
            }
        }

        // Leave player launch to the Activity started with NEW_TASK (see the note below)
        startActivity(Intent(this, MainActivity::class.java).apply {
            flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK
            putExtra("campaignKey", campaignKey)
        })
        finish()
    }
}

final common = ShopLiveCommon();
final player = ShopLivePlayer();

void handleDeepLink(Uri uri) {
  uri.queryParameters.forEach((key, value) {
    switch (key) {
      case 'ak':
        common.setAccessKey(accessKey: value);
        break;
      case 'ck':
        break; // Used right below
      case 'utm_source':
        common.setUtmSource(utmSource: value);
        break;
      case 'utm_medium':
        common.setUtmMedium(utmMedium: value);
        break;
      case 'utm_campaign':
        common.setUtmCampaign(utmCampaign: value);
        break;
      case 'utm_content':
        common.setUtmContent(utmContent: value);
        break;
      default:
        player.addParameter(key: key, value: value);
    }
  });

  final campaignKey = uri.queryParameters['ck'];
  if (campaignKey != null) {
    player.play(data: ShopLivePlayerData(campaignKey: campaignKey));
  }
}

import ShopLiveSDK
import ShopliveSDKCommon

let user = ShopLiveCommonUser(userId: "{USER_ID}", userName: "{USER_NAME}")
ShopLiveCommon.setUser(user: user)

ShopLive.play(data: .init(campaignKey: "{CAMPAIGN_KEY}"))

val user = ShopLiveCommonUser(userId = "{USER_ID}").apply {
    userName = "{USER_NAME}"
}
ShopLive.setUser(user)

ShopLive.play(this, ShopLivePlayerData(campaignKey))

// common and player reuse the instances created in Mission 1
final user = ShopLiveCommonUser(userId: "{USER_ID}", userName: "{USER_NAME}");
common.setUser(accessKey: "{ACCESS_KEY}", user: user);

player.play(data: ShopLivePlayerData(campaignKey: "{CAMPAIGN_KEY}"));

let user = ShopLiveCommonUser(
    userId: "{USER_ID}",
    userName: "{USER_NAME}",
    age: 25,
    gender: .male,
    userScore: 80,
    custom: ["grade": "vip"])

ShopLiveCommon.setUser(user: user)
ShopLive.play(data: .init(campaignKey: "{CAMPAIGN_KEY}"))

val user = ShopLiveCommonUser(userId = "{USER_ID}").apply {
    userName = "{USER_NAME}"
    gender = ShopLiveCommonUserGender.MALE
    age = 25
    userScore = 20
}
ShopLive.setUser(user)

final user = ShopLiveCommonUser(
  userId: "{USER_ID}",
  userName: "{USER_NAME}",
  gender: ShopLiveCommonUserGender.MALE,
  userScore: 100,
  age: 25,
  custom: {"key": "value"},
);
common.setUser(accessKey: "{ACCESS_KEY}", user: user);

ShopLiveCommon.setAuthToken(authToken: "{USER_JWT}")
ShopLive.play(data: .init(campaignKey: "{CAMPAIGN_KEY}"))

ShopLiveCommon.setAuthToken("{USER_JWT}")
ShopLive.play(this, ShopLivePlayerData(campaignKey))

common.setAuthToken(userJWT: "{USER_JWT}");
player.play(data: ShopLivePlayerData(campaignKey: "{CAMPAIGN_KEY}"));

func onSetUserName(_ payload: [String: Any]) {
    payload.forEach { key, value in
        print("onSetUserName key: \(key) value: \(value)")
    }
}

override fun onSetUserName(jsonObject: JSONObject) {
    super.onSetUserName(jsonObject)
    Log.d(TAG, "userId=${jsonObject.get("userId")}, userName=${jsonObject.get("userName")}")
}

player.userInfo.listen((data) {
  print("userInfo: ${data.userInfo}");
});

func handleReceivedCommand(_ command: String, data: [String: Any]?) {
    switch command {
    case "LOGIN_REQUIRED":
        // Navigate to the login screen → on success, reset the user info and relaunch the player
        break
    default:
        break
    }
}

override fun onReceivedCommand(context: Context, command: String, data: JSONObject) {
    when (command) {
        "LOGIN_REQUIRED" -> {
            // Navigate to the login screen → on success, reset the user info and relaunch the player
        }
    }
}

player.receivedCommand.listen((data) {
  switch (data.command) {
    case "LOGIN_REQUIRED":
      // Navigate to the login screen → on success, reset the user info and relaunch the player
      break;
    default:
      break;
  }
});

// Log out — reset the user info (clears the JWT and profile)
ShopLiveCommon.setAuthToken(authToken: nil)
ShopLiveCommon.setUser(user: nil)

// Clear at once — clears the JWT · user · accessKey
ShopLiveCommon.clearAuth()
ShopLiveCommon.setAccessKey(accessKey: "{ACCESS_KEY}")   // set it again before the next playback

// Log out — reset the user info (clears the JWT and profile)
ShopLiveCommon.setAuthToken(null)
ShopLiveCommon.setUser(null)
// ShopLive.resetUser() is the same as setUser(null)

// Clear at once — clears only the user · JWT (accessKey is kept)
ShopLiveCommon.clearAuth()

// Log out — reset the user info
common.setAuthToken(userJWT: null);
common.clearAuth();   // Flutter's setUser does not accept null

let inputFont = UIFont.systemFont(ofSize: 14, weight: .regular)
let sendButtonFont = UIFont.systemFont(ofSize: 14, weight: .medium)

ShopLive.setChatViewFont(inputBoxFont: inputFont, sendButtonFont: sendButtonFont)

val nanumGothic = ResourcesCompat.getFont(requireContext(), R.font.nanumgothic)
ShopLiveCommon.setTextTypeface(nanumGothic)

func handleNavigation(with url: URL) {
    let safari = SFSafariViewController(url: url)
    present(safari, animated: true)
}

override fun handleNavigation(context: Context, url: String) {
    val intent = Intent(this@YourActivity, WebViewActivity::class.java)
    intent.putExtra("url", url)
    startActivity(intent)
}

player.handleNavigation.listen((data) {
  launchUrl(Uri.parse(data.url), mode: LaunchMode.externalApplication);
});

func handleDownloadCoupon(with couponId: String, result: @escaping (ShopLiveCouponResult) -> Void) {
    let couponResult = ShopLiveCouponResult(
        couponId: couponId, success: true,
        message: "Coupon download success!",
        status: .SHOW, alertType: .ALERT)
    result(couponResult)
}

override fun handleDownloadCoupon(
    context: Context,
    couponId: String,
    callback: ShopLiveHandlerCallback
) {
    callback.couponResult(
        isDownloadSuccess = true,
        message = "Coupon download success!",
        couponStatus = ShopLive.CouponPopupStatus.HIDE,
        alertType = ShopLive.CouponPopupResultAlertType.ALERT
    )
}

player.handleDownloadCoupon.listen((data) async {
  await player.sendDownloadCouponResult(
    couponId: data.couponId,
    success: true,
    message: "Coupon download success!",
    popupStatus: "KEEP",
    alertType: "ALERT",
  );
});

func handleCustomAction(with id: String, type: String, payload: Any?, result: @escaping (ShopLiveCustomActionResult) -> Void) {
    let actionResult = ShopLiveCustomActionResult(
        id: id, success: true, message: "success!",
        status: .SHOW, alertType: .ALERT)
    result(actionResult)
}

override fun handleCustomAction(
    context: Context,
    id: String,
    type: String,
    payload: JSONObject,
    callback: ShopLiveHandlerCallback
) {
    callback.customActionResult(
        isSuccess = true,
        message = "success!",
        couponStatus = ShopLive.CouponPopupStatus.HIDE,
        alertType = ShopLive.CouponPopupResultAlertType.ALERT
    )
}

player.handleCustomAction.listen((data) async {
  await player.sendCustomActionResult(
    id: data.id,
    success: true,
    message: "success!",
    popupStatus: "SHOW",
    alertType: "ALERT",
  );
});

// ShopLiveSDKDelegate
func handleReceivedCommand(_ command: String, data: [String: Any]?) {
    switch command {
    case "CLICK_PRODUCT_DETAIL":
        // data: info about the selected product
        break
    case "CLICK_PRODUCT_CART":
        // data: info about the product added to the cart
        break
    default:
        break
    }
}

// ShopLiveHandler
override fun onReceivedCommand(context: Context, command: String, data: JSONObject) {
    when (command) {
        "CLICK_PRODUCT_DETAIL" -> {
            // data: info about the selected product
        }
        "CLICK_PRODUCT_CART" -> {
            // data: info about the product added to the cart
        }
    }
}

final player = ShopLivePlayer();

player.receivedCommand.listen((event) {
  switch (event.command) {
    case 'CLICK_PRODUCT_DETAIL':
      // event.data: info about the selected product
      break;
    case 'CLICK_PRODUCT_CART':
      // event.data: info about the product added to the cart
      break;
  }
});

func handleNavigation(with url: URL) {
    // url: the detail URL set on the selected product or banner
    print("handleNavigation \(url)")
}

override fun handleNavigation(context: Context, url: String) {
    Log.d(TAG, "handleNavigation url=$url")
}

final player = ShopLivePlayer();

player.handleNavigation.listen((event) {
  debugPrint("handleNavigation : ${event.url}");
});

ShopLive.hookNavigation { url in
    // url: the detail URL set on the selected product or banner
    print("hookNavigation \(url)")
}

// URI Scheme
let scheme = "{your_scheme}://{your_host}?ak=xxx&ck=yyy"
ShopLive.setShareScheme(scheme, shareDelegate: nil)

// Or a web URL
ShopLive.setShareScheme("https://www.share_link.com/?ak=xxx&ck=yyy", shareDelegate: nil)

// URI Scheme
val scheme = "{your_scheme}://{your_host}?ak=xxx&ck=yyy"
ShopLive.setShareScheme(scheme)

// Or a web URL
ShopLive.setShareScheme("https://www.share_link.com/?ak=xxx&ck=yyy")

final player = ShopLivePlayer();

player.setShareScheme(
  shareSchemeUrl: "{your_scheme}://{your_host}?ak=xxx&ck=yyy",
);

// 1) Assign a delegate to receive the shared data
ShopLive.setShareScheme(scheme, shareDelegate: self)

// 2) Have the delegate present the app's share UI
extension MainViewController: ShopLivePlayerShareDelegate {
    func handleShare(data: ShopLivePlayerShareData) {
        guard let urlString = data.url, let url = URL(string: urlString) else { return }

        let activityVC = UIActivityViewController(activityItems: [url],
                                                  applicationActivities: nil)
        ShopLive.viewController?.present(activityVC, animated: true, completion: nil)
    }
}

// ShopLiveHandler — if you do not override it, the SDK shows its default share sheet
override fun handleShare(context: Context, data: ShopLivePlayerShareData) {
    val inflater = getSystemService(LAYOUT_INFLATER_SERVICE) as LayoutInflater
    val view = inflater.inflate(R.layout.custom_share_dialog, null)

    AlertDialog.Builder(context)
        .setView(view)
        .create()
        .show()
}

// Whether PIP is allowed at all (shared precondition for in-app PIP and OS PIP)
ShopLive.setEnabledPictureInPictureMode(isEnabled: true)

// Set size, position, corners, and the close button all at once
let config = ShopLiveInAppPipConfiguration(
    useCloseButton: true,
    pipPosition: .bottomRight,
    enableSwipeOut: true,
    pipSize: ShopLiveInAppPipSize(pipMaxSize: 200),
    pipRadius: 10,
    pipPinPositions: [.topLeft, .topRight, .bottomLeft, .bottomRight],
    closeButtonConfig: ShopLiveCloseButtonConfig(position: .topRight, width: 30, height: 30, offsetX: 3, offsetY: 3, color: .white)
)
ShopLive.setInAppPipConfiguration(config: config)

final player = ShopLivePlayer();

// In-app PIP and the preview window are the same window, so one call configures both
player.setPreviewOption(
  data: ShopLivePlayerPreviewData(
    campaignKey: 'YOUR_CAMPAIGN_KEY',
    useCloseButton: true,
    enableSwipeOut: true,
    pipRadius: 10,
    pipMaxSize: 400,
    position: 'BOTTOM_RIGHT',
  ),
);

ShopLive.setEnabledOSPictureInPictureMode(isEnabled: true)

// Allow entering OS PIP (default true)
ShopLive.setEnabledPictureInPictureMode(true)

// PIP window ratio — defaults to 9:16 if not set
// RATIO_1X1 / RATIO_1X2 / RATIO_2X3 / RATIO_3X4 / RATIO_9X16
ShopLive.setPIPRatio(ShopLivePIPRatio.RATIO_9X16)

ShopLivePermissionManager.request(this, ShopLivePermissionType.DRAW_OVERLAY) { hasPermission ->
    // hasPermission == true means overlay permission is already granted
}

// app/build.gradle
implementation "cloud.shoplive:shoplive-permission:$shoplive_sdk_version"

// Switch to in-app PIP
ShopLive.startPictureInPicture()

// Return to full screen
ShopLive.stopPictureInPicture()

// Switch to OS PIP — set true if you need to wait for the overlay permission screen to close
ShopLive.startPictureInPicture(shouldDelayForOverlayPermissionFlow = false)

// Return to full screen
ShopLive.stopPictureInPicture()

final player = ShopLivePlayer();

player.startPictureInPicture();
player.stopPictureInPicture();

// Area near the screen edges where PIP should not be allowed to enter
let offsetApplied = ShopLive.setPictureInPictureFloatingOffset(
    offset: UIEdgeInsets(top: 60, left: 0, bottom: 90, right: 0))

// Margin around the PIP itself
let paddingApplied = ShopLive.setPictureInPicturePadding(
    padding: UIEdgeInsets(top: 8, left: 8, bottom: 8, right: 8))

let previewData = ShopLivePreviewData(
    campaignKey: "YOUR_CAMPAIGN_KEY",
    keepWindowStateOnPlayExecuted: true,
    referrer: nil,
    isMuted: true,
    isEnabledVolumeKey: false,
    resolution: .PREVIEW
)

ShopLive.preview(data: previewData) {
    // To go full screen when the preview window is tapped
    ShopLive.play(data: .init(campaignKey: "YOUR_CAMPAIGN_KEY"))
}

ShopLive.showPreviewPopup(this, ShopLivePreviewData("YOUR_CAMPAIGN_KEY").apply {
    useCloseButton = true
    enabledSwipeOut = true
    resolutionType = ShopLivePreviewResolutionType.LIVE

    onClickListener = View.OnClickListener { view ->
        // Preview → player transition animation
        ShopLive.setPreviewTransitionAnimation(this@MainActivity, view)
        ShopLive.play(this@MainActivity, ShopLivePlayerData("YOUR_CAMPAIGN_KEY"))
    }
})

final player = ShopLivePlayer();

// 1) Set the options first
player.setPreviewOption(
  data: ShopLivePlayerPreviewData(
    campaignKey: 'YOUR_CAMPAIGN_KEY',
    useCloseButton: true,
    enableSwipeOut: true,
    pipRadius: 10,
    pipMaxSize: 400,
    position: 'BOTTOM_RIGHT',
  ),
);

// 2) Start the preview
player.showPreview(campaignKey: 'YOUR_CAMPAIGN_KEY');

player.hidePreview();

// Save the options once — campaignKey gets overwritten by the value passed to showPreviewPopup
ShopLive.setPreviewOptions(ShopLivePreviewData("YOUR_CAMPAIGN_KEY").apply {
    useCloseButton = true
    enabledSwipeOut = true
})

// Only campaignKey is needed to present it
ShopLive.showPreviewPopup(this, "YOUR_CAMPAIGN_KEY")

<cloud.shoplive.sdk.ShopLivePreview
    android:id="@+id/preview"
    android:layout_width="120dp"
    android:layout_height="180dp" />

import ShopLiveSDK
import ShopliveSDKCommon

final class PreviewCell: UITableViewCell {
    private var preview: ShopLivePlayerPreview?

    func configure(campaignKey: String) {
        let preview = ShopLivePlayerPreview()
        preview.translatesAutoresizingMaskIntoConstraints = false
        contentView.addSubview(preview)
        NSLayoutConstraint.activate([
            preview.topAnchor.constraint(equalTo: contentView.topAnchor),
            preview.leadingAnchor.constraint(equalTo: contentView.leadingAnchor),
            preview.widthAnchor.constraint(equalToConstant: 120),
            preview.heightAnchor.constraint(equalToConstant: 180)
        ])
        self.preview = preview

        preview.action(.initialize)
        preview.resultHandler = { result in
            switch result {
            case .didChangeCampaignStatus(let status):
                print(status)
            case .onError(let code, let message):
                print(code, message)
            case .handleReceivedCommand(let command, let payload):
                print(command, payload ?? [:])
            default:
                break   // for other cases, see the Preview components reference
            }
        }
        // replaces the global accessKey with this value
        preview.action(.start(accessKey: "{ACCESS_KEY}", campaignKey: campaignKey, referrer: nil))
    }

    override func prepareForReuse() {
        super.prepareForReuse()
        preview?.action(.close)   // clean up on cell reuse — removes it from the parent view
        preview = nil
    }
}

// owner is the LifecycleOwner (host Activity/Fragment) received in the adapter constructor
class PreviewAdapter(
    private val owner: LifecycleOwner,
    private val campaignKeys: List<String>,
) : RecyclerView.Adapter<PreviewAdapter.ViewHolder>() {

    override fun getItemCount() = campaignKeys.size

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
        val view = LayoutInflater.from(parent.context)
            .inflate(R.layout.item_preview, parent, false)
        return ViewHolder(view)
    }

    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
        holder.onBind(campaignKeys[position])
    }

    // Starts/releases playback as RecyclerView attaches and detaches the cell
    override fun onViewAttachedToWindow(holder: ViewHolder) {
        super.onViewAttachedToWindow(holder)
        holder.onViewAttachedToWindow()
    }

    override fun onViewDetachedFromWindow(holder: ViewHolder) {
        holder.onViewDetachedFromWindow()
        super.onViewDetachedFromWindow(holder)
    }

    inner class ViewHolder(view: View) : RecyclerView.ViewHolder(view) {
        private val preview: ShopLivePreview = view.findViewById(R.id.preview)

        fun onBind(campaignKey: String) {
            preview.initializePlayer()
            preview.setLifecycleObserver(owner)
            preview.campaignKey = campaignKey
            preview.setMuted(true)
        }

        fun onViewAttachedToWindow() {
            preview.start() // Uses the accessKey already set via ShopLiveCommon.setAccessKey in Mission 1
        }

        fun onViewDetachedFromWindow() {
            preview.release()
        }
    }
}

import ShopliveSDKCommon

let products = [
    ShopLiveConversionProductData(
        productId: "productId",
        customerProductId: "customerProductId",
        sku: "sku",
        url: "url",
        purchaseQuantity: 1,
        purchaseUnitPrice: 1000.0)
]

ShopLiveEvent.sendConversionEvent(data: .init(
    type: "purchase",
    products: products,
    orderId: "orderId",
    referrer: "referrer",
    custom: ["campaignKey": "campaignKey"]))

ShopLiveEvent.sendConversionEvent(
    ShopLiveConversionData(
        "purchase",
        products = listOf(
            ShopLiveConversionProductData(
                productId = "productId",
                customerProductId = "customerProductId",
                sku = "sku",
                url = "url",
                purchaseQuantity = 1,
                purchaseUnitPrice = 1000.0,
            )
        ),
        orderId = "orderId",
        referrer = "referrer",
        custom = mapOf("campaignKey" to "campaignKey"),
    )
)

// Logged-in user — same as when watching
ShopLiveCommon.setUser(user: ShopLiveCommonUser(userId: "{USER_ID}"))
// Or a JWT signed by your backend
ShopLiveCommon.setAuthToken(authToken: "{USER_JWT}")

// Not logged in — only if the app manages a device identifier
ShopLiveCommon.setAnonId(anonId: "{DEVICE_ID}")

// Logged-in user — same as when watching
ShopLive.setUser(ShopLiveCommonUser(userId = "{USER_ID}"))
// Or a JWT signed by your backend
ShopLiveCommon.setAuthToken("{USER_JWT}")

// Not logged in — only if the app manages a device identifier
ShopLiveCommon.setAnonId("{DEVICE_ID}")

// ShopLiveSDKDelegate
private var isMuted = false

func onEvent(name: String, feature: ShopLiveLog.Feature, campaign: String, payload: [String: Any]) {
    switch name {
    case "video_muted":
        isMuted = true
    case "video_unmuted":
        isMuted = false
    default:
        break
    }
}

// ShopLiveHandler
private var isMuted = false

override fun onEvent(context: Context, data: ShopLiveLog.Data) {
    when (data.name) {
        "video_muted" -> isMuted = true
        "video_unmuted" -> isMuted = false
    }
}

final player = ShopLivePlayer();
bool isMuted = false;

player.log.listen((data) {
  switch (data.name) {
    case "video_muted":
      isMuted = true;
      break;
    case "video_unmuted":
      isMuted = false;
      break;
  }
});

ShopLive.setMuteWhenPlayStart(isMuted)
ShopLive.play(data: .init(campaignKey: "{CAMPAIGN_KEY}"))

ShopLive.setMuteWhenPlayStart(isMuted)
ShopLive.play(this, ShopLivePlayerData("{CAMPAIGN_KEY}"))

final player = ShopLivePlayer();

player.setMuteWhenPlayStart(isMute: isMuted);
player.play(data: ShopLivePlayerData(campaignKey: "{CAMPAIGN_KEY}"));

// Pass one of the values from the table above (.PIP · .KEEP · .CLOSE)
ShopLive.setNextActionOnHandleNavigation(actionType: .PIP)

// Pass one of the values from the table above (PIP · KEEP · CLOSE)
ShopLive.setNextActionOnHandleNavigation(ActionType.PIP)

ShopLive.sendCommandMessage(
    command: "SET_BRAND_FAVORITE",
    payload: ["identifier": "brand-identifier", "favorite": true])

ShopLive.sendCommandMessage(
    "SET_BRAND_FAVORITE",
    mapOf("identifier" to "brand-identifier", "favorite" to true)
)

func handleReceivedCommand(_ command: String, data: [String: Any]?) {
    switch command {
    case "ON_CLICK_BRAND_FAVORITE_BUTTON":
        guard let identifier = data?["identifier"] as? String else {
            return
        }
        // Handle follow in your app/backend, then send back the confirmed final state as-is
        updateFavorite(identifier: identifier) { isFavorite in
            ShopLive.sendCommandMessage(
                command: "SET_BRAND_FAVORITE",
                payload: ["identifier": identifier, "favorite": isFavorite])
        }
    case "ON_CHANGED_BRAND_FAVORITE":
        // Reports the result once the follow state has changed
        break
    default:
        break
    }
}

override fun onReceivedCommand(context: Context, command: String, data: JSONObject) {
    when (command) {
        "ON_CLICK_BRAND_FAVORITE_BUTTON" -> {
            val identifier = data.getString("identifier")
            // Handle follow in your app/backend, then send back the confirmed final state as-is
            updateFavorite(identifier) { isFavorite ->
                ShopLive.sendCommandMessage(
                    "SET_BRAND_FAVORITE",
                    mapOf("identifier" to identifier, "favorite" to isFavorite)
                )
            }
        }
        "ON_CHANGED_BRAND_FAVORITE" -> {
            // Reports the result once the follow state has changed
            val identifier = data.getString("identifier")
        }
    }
}

let configuration = WKWebViewConfiguration()
configuration.allowsInlineMediaPlayback = true
let webView = WKWebView(frame: view.bounds, configuration: configuration)

webView.webViewClient = object : WebViewClient() {
    override fun shouldOverrideUrlLoading(
        view: WebView?,
        request: WebResourceRequest?
    ): Boolean {
        // Handle it here only if you have a separate scheme
        val url = request?.url ?: return super.shouldOverrideUrlLoading(view, request)
        if (url.toString().startsWith("market")) {
            val intent = Intent(Intent.ACTION_VIEW).apply {
                data = url
            }
            startActivity(intent)
            return true
        }
        return super.shouldOverrideUrlLoading(view, request)
    }
}

webView.webChromeClient = object : WebChromeClient() {
    override fun onCreateWindow(
        view: WebView?,
        isDialog: Boolean,
        isUserGesture: Boolean,
        resultMsg: Message?
    ): Boolean {
        view ?: return true
        resultMsg ?: return true
        val subWebView = WebView(view.context)
        subWebView.webViewClient = object : WebViewClient() {
            // If you support devices on API 23 or lower, also implement the String overload
            override fun shouldOverrideUrlLoading(view: WebView?, url: String?): Boolean {
                url ?: return false
                if (url.startsWith("http")) {
                    webView.loadUrl(url)
                }
                return true
            }
            override fun shouldOverrideUrlLoading(
                view: WebView?,
                request: WebResourceRequest?
            ): Boolean {
                val url = request?.url?.toString() ?: return false
                if (url.startsWith("http")) {
                    webView.loadUrl(url)
                }
                return true
            }
        }
        val viewTransport = (resultMsg.obj as? WebView.WebViewTransport) ?: return true
        viewTransport.webView = subWebView
        resultMsg.sendToTarget()
        return true
    }
}

val intent = Intent(Intent.ACTION_VIEW).apply {
    data = Uri.parse(url)
}
startActivity(intent)

ShopLive.indicatorColor = UIColor.purple

ShopLive.setLoadingProgressColor(Color.RED)

var images: [UIImage] = []

for i in 1...11 {
    images.append(.init(named: "loading\(i)")!)
}

ShopLive.setLoadingAnimation(images: images)

ShopLive.setLoadingAnimation(R.drawable.progress_animation)

<?xml version="1.0" encoding="utf-8"?>
<animation-list xmlns:android="http://schemas.android.com/apk/res/android"
    android:oneshot="false">

    <item android:drawable="@drawable/loading1" android:duration="100" />
    <item android:drawable="@drawable/loading2" android:duration="100" />
    <item android:drawable="@drawable/loading3" android:duration="100" />
    <item android:drawable="@drawable/loading4" android:duration="100" />
</animation-list>

// Keep playing even if headphones are unplugged (default false — stop)
ShopLive.setKeepPlayVideoOnHeadphoneUnplugged(true)
// Keep playing, but muted
ShopLive.setKeepPlayVideoOnHeadphoneUnplugged(true, isMute: true)
print(ShopLive.isKeepPlayVideoOnHeadPhoneUnplugged())

// Automatically resume playback when the call ends (iOS default false — stays stopped)
ShopLive.setAutoResumeVideoOnCallEnded(true)
print(ShopLive.isAutoResumeVideoOnCallEnded())

// Keep playing even if headphones are unplugged (default false — stop)
ShopLive.setKeepPlayVideoOnHeadphoneUnplugged(true, false)
// Keep playing, but muted
ShopLive.setKeepPlayVideoOnHeadphoneUnplugged(true, true)

// Automatically resume playback when the call ends (Android default true)
ShopLive.setAutoResumeVideoOnCallEnded(false)

handleNavigation(with url: URL)

handleNavigation(context, url: String)

handleNavigation → {url}

handleDownloadCoupon(with couponId: String, result: (ShopLiveCouponResult) -> Void)

handleDownloadCoupon(context, couponId: String, callback: ShopLiveHandlerCallback)

handleDownloadCoupon → {couponId}

handleCustomAction(with id: String, type: String, payload: Any?, result: (ShopLiveCustomActionResult) -> Void)

handleCustomAction(context, id: String, type: String, payload: JSONObject, callback: ShopLiveHandlerCallback)

handleCustomAction → {id, type, payload: String}

handleChangeCampaignStatus(status: String)

onChangeCampaignStatus(context, campaignStatus: String)

changeCampaignStatus → {campaignStatus}

handleCampaignInfo(campaignInfo: [String: Any])

onCampaignInfo(campaignInfo: JSONObject)

campaignInfo → {campaignInfo: Map}

handleChangedPlayerStatus(status: String)

onChangedPlayerStatus(isPipMode: Boolean, playerLifecycle: PlayerLifecycle)

changedPlayerStatus

onSetUserName(_ payload: [String: Any])

onSetUserName(jsonObject: JSONObject)

userInfo → {userInfo: Map}

handleError(code: String, message: String)

onError(context, error: ShopLiveCommonError)

error → {code, message}

handleReceivedCommand(_ command: String, data: [String: Any]?)

onReceivedCommand(context, command: String, data: JSONObject)

receivedCommand → {command, data: Map}

handleCommand(_ command: String, with payload: Any?)

playerPanGesture(state: UIGestureRecognizer.State, position: CGPoint)

handlePreviewTouchGesture()

onEvent(name: String, feature: ShopLiveLog.Feature, campaign: String, payload: [String: Any])

onEvent(context, data: ShopLiveLog.Data)

log → {name, feature, campaignKey, payload: Map}

ShopLivePlayerShareDelegate.handleShare(data: ShopLivePlayerShareData)

handleShare(context, data: ShopLivePlayerShareData)

onUserCloseAction(isPipMode: Boolean)

ShopLive.setCloseHandler(_ handler: (ShopLiveViewHiddenActionType) -> Void)
ShopLive.setPreviewCloseHandler(_ handler: (ShopLiveViewHiddenActionType) -> Void)

onClose(type: ShopLivePresentType, reason: ShopLiveViewHiddenActionType)

previewClose → ShopLivePreviewClose {campaignKey, reason}

ShopLivePlayerPreviewDelegate.handlePlaybackEvent(_ event: ShopLivePreviewPlaybackEvent)

ShopLivePreview.setOnPlaybackEventListener(OnPlaybackEventListener)

// Coupon result. Pass this to the result parameter of handleDownloadCoupon
ShopLiveCouponResult(couponId: String,
                     success: Bool,
                     message: String?,
                     status: ShopLiveResultStatus,      // SHOW / HIDE / KEEP
                     alertType: ShopLiveResultAlertType) // ALERT / TOAST

// Custom action result. Pass this to the result parameter of handleCustomAction
ShopLiveCustomActionResult(id: String,
                           success: Bool,
                           message: String?,
                           status: ShopLiveResultStatus,
                           alertType: ShopLiveResultAlertType)

// Both go into the callback object the SDK handed you
callback.couponResult(
    isDownloadSuccess = true,
    message = successMessage,
    couponStatus = ShopLive.CouponPopupStatus.HIDE,          // SHOW / HIDE / KEEP
    alertType = ShopLive.CouponPopupResultAlertType.TOAST    // ALERT / TOAST
)

callback.customActionResult(
    isSuccess = true,
    message = successMessage,
    couponStatus = ShopLive.CouponPopupStatus.HIDE,
    alertType = ShopLive.CouponPopupResultAlertType.ALERT
)

// Flutter alone sends the result through a separate method, not a stream
await ShopLivePlayer().sendDownloadCouponResult(
  couponId: couponId,
  success: true,
  message: successMessage,
  popupStatus: "HIDE",   // SHOW / HIDE / KEEP
  alertType: "TOAST",    // ALERT / TOAST
);

await ShopLivePlayer().sendCustomActionResult(
  id: id,
  success: true,
  message: successMessage,
  popupStatus: "HIDE",
  alertType: "ALERT",
);

// Legacy — user info. Replacement: ShopLiveCommon.setUser(user:accessKey:). The constructor parameter label is userName: (the original name: doesn't compile) · Mission 3
ShopLive.user: ShopLiveCommonUser?

// Legacy — user info JWT (secure auth). Replacement: ShopLiveCommon.setAuthToken(authToken:) · Mission 3
ShopLive.authToken: String?

// Legacy (scheduled for removal in v2) — sets the AccessKey with a single with accessKey: String. Replacement: ShopLiveCommon.setAccessKey(accessKey:)
ShopLive.configure

// Gets the JWT set with setAuthToken. If none, the JWT generated by setUser · Mission 3
ShopLiveCommon.getAuthToken() -> String?

// Set user info (accessKey keeps whatever value is already set). To specify accessKey together, see ShopLiveCommon.setUser(accessKey, user) · Mission 3
ShopLive.setUser(user: ShopLiveCommonUser?)

// Legacy — ShopLiveUser type is no longer used. Replacement: the ShopLiveCommonUser version above
ShopLive.setUser(user: ShopLiveUser)

// Set the user info JWT (secure auth) · Mission 3
ShopLive.setAuthToken(authToken: String)

// Read the setting above · Mission 3
ShopLive.getAuthToken(): String?

// Legacy — set the AccessKey. Replacement: ShopLive.setAccessKey(accessKey:)
ShopLive.configure(accessKey: String)

// Whether to allow entering in-app PIP/OS PIP at all (turning it off also disables auto-PIP when leaving the player) · Default true · Mission 8
setEnabledPictureInPictureMode(isEnabled: Bool)

// Fine-tunes in-app PIP size, position, and close button (show the close button with the config.useCloseButton property, which replaces the legacy useCloseButton(_:); close button look = closeButtonConfig). Takes priority over the older individual setters · Mission 8
setInAppPipConfiguration(config: ShopLiveInAppPipConfiguration)

// Calculate the actual render size given a PIP setting and aspect ratio
getPreviewSize(inAppPipConfiguration: ShopLiveInAppPipConfiguration, videoRatio: CGSize) -> CGSize

// Attach a custom view over the Preview screen (you must turn off the close button separately)
addSubViewToPreview(subView: UIView)

// Switch from full screen to in-app PIP · Default scale 0.4 · Mission 8
startPictureInPicture(with position: ShopLive.PipPosition, scale: CGFloat) / startPictureInPicture()

// Switch from PIP to full screen · Mission 8
stopPictureInPicture()

// Whether to keep the last playback state (PIP/full screen) when returning to the app after leaving via OS PIP, or always switch back to full screen · Default false (always full screen) · Mission 8
setKeepWindowStyleOnReturnFromOsPip(_ keep: Bool)

// Read the setting above · Mission 8
isKeepWindowStyleOnReturnFromOsPip() -> Bool

// Whether to separately allow only OS PIP (unrelated to the in-app PIP setting) · Default true · Mission 8
setEnabledOSPictureInPictureMode(isEnabled: Bool)

// Top/bottom/left/right padding for the area in-app PIP can move within. Returns false and applies the default if the value is invalid · Default top/left/right/bottom 20 · Mission 8
setPictureInPicturePadding(padding: UIEdgeInsets) -> Bool

// Restrict the area in-app PIP can move within itself, as an offset. Returns false if the value is invalid · Mission 8
setPictureInPictureFloatingOffset(offset: UIEdgeInsets) -> Bool

// Legacy — whether to show the close button in Preview/PIP mode. Replacement: setInAppPipConfiguration(config:)'s useCloseButton property
useCloseButton(_ use: Bool)

// Whether to automatically switch to PIP when leaving the player · Mission 8
ShopLive.setEnabledPictureInPictureMode(isEnabled: Boolean)

// The default aspect ratio when the PIP screen starts (RATIO_1X1 / 1X2 / 2X3 / 3X4 / 9X16) · Mission 8
ShopLive.setPIPRatio(pipRatio: ShopLivePIPRatio)

// Whether to switch to PIP instead of closing when leaving the screen via the back button · Mission 8
ShopLive.setEnterPipModeOnBackPressed(isEnterPipMode: Boolean)

// Switch from full screen to PIP. Legacy: the parameterless startPictureInPicture() is deprecated (this signature calls shouldDelayForOverlayPermissionFlow = false) · Mission 8
ShopLive.startPictureInPicture(shouldDelayForOverlayPermissionFlow: Boolean)

// Switch from PIP to full screen · Mission 8
ShopLive.stopPictureInPicture()

// Whether to switch to PIP instead of closing when leaving the screen via the back button · Mission 8
ShopLivePlayer().setEnterPipModeOnBackPressed(isEnterPipMode: bool)

// Switch full screen ↔ PIP · Mission 8
ShopLivePlayer().startPictureInPicture() / stopPictureInPicture()

// Whether to show the close button in Preview/PIP mode
ShopLivePlayer().useCloseButton(canUse: bool)

// Set the scheme/URL to pass to the share popup. Passing shareDelegate implements your own custom share UI instead of the system share sheet · Mission 7
setShareScheme(_ scheme: String?, shareDelegate: ShopLivePlayerShareDelegate?)

// Intercept only the URL as a closure when a product/banner is selected — registering it means the handleNavigation delegate isn't called (iOS only) · Mission 6
hookNavigation(navigation: @escaping (URL) -> Void)

// Set the player's next action after selecting a product/banner link (PIP/KEEP/CLOSE) · Default PIP · Mission 11
setNextActionOnHandleNavigation(actionType: ActionType)

// Read the setting above · Mission 11
getNextActionTypeOnHandleNavigation() -> ActionType

// Set the scheme/URL to pass to the share popup · Mission 7
ShopLive.setShareScheme(shareSchemeUrl: String?)

// Set the player's next action after selecting a product/banner link (PIP/KEEP/CLOSE) · Mission 11
ShopLive.setNextActionOnHandleNavigation(type: ActionType)

// Set the scheme/URL to pass when sharing · Mission 7
ShopLivePlayer().setShareScheme(shareSchemeUrl: String)

// Set the next action after selecting a product/banner link (show/hide/keep) — passed to native as a string, but the Android receiver reads it as an integer, so it's actually ignored (see Mission 11) · Mission 11
ShopLivePlayer().setNextActionOnHandleNavigation(type: ShopLiveActionType)

// Set the chat input field/send button font · Default System font · Mission 4
setChatViewFont(inputBoxFont: UIFont?, sendButtonFont: UIFont?)

// Show video loading progress as an image-sequence animation
setLoadingAnimation(images: [UIImage])

// Force-attach a view that ShopLive's policy otherwise wouldn't allow adding via ordinary addSubview
playerWindow?.forceAddSubView(_:)

// Hide/show the status bar during full-screen playback (always shown automatically in InAppPip) · Default true (shown)
setVisibleStatusBar(isVisible: Bool)

// Set the loading indicator color · Mission 11
indicatorColor: UIColor

// Set how to maintain the video aspect ratio
setResizeMode(mode: ShopLiveResizeMode)

// Set the loading progress bar color · Mission 11
ShopLive.setLoadingProgressColor(@ColorInt colorInt: Int)

// Set the loading progress bar as an image animation (pass 0 to clear it) · Mission 11
ShopLive.setLoadingAnimation(@DrawableRes drawableRes: Int)

// Set the chat input field/send button font, shared · Mission 4
ShopLive.setChatViewTypeface(typeface: Typeface?)

// Hide/show the screen's status bar · Default false (hidden)
ShopLive.setVisibleStatusBar(isVisible: Boolean)

// Changes the status bar and navigation bar colors. Call before play. ShopLivePlayerSystemBarColorData(statusBarColor · navigationBarColor default black DEFAULT_COLOR, isTaskBarOpened default false)
ShopLive.setSystemBarColor(data: ShopLivePlayerSystemBarColorData)

// Resets the color setting above to the default. Call before play
ShopLive.clearSystemBarColor()

// Show/dismiss a custom DialogFragment over the player screen
ShopLive.showDialogFragment(dialogFragment: DialogFragment?) / closeDialogFragment()

// Whether to allow screenshots of the broadcast screen
ShopLive.setPlayerScreenCaptureEnabled(isEnabled: Boolean)

// Set how to maintain the video aspect ratio · Default CENTER_CROP
ShopLive.setResizeMode(resizeMode: ShopLiveResizeMode)

// Set how to maintain the video aspect ratio
ShopLivePlayer().setResizeMode(mode: ShopLiveResizeMode)

// Set whether to auto-resume once the video returns after a call ends · Default false (no auto-resume) · Mission 11
setAutoResumeVideoOnCallEnded(_ autoResume: Bool)

// Read the setting above · Mission 11
isAutoResumeVideoOnCallEnded() -> Bool

// Whether to keep playing when the earphones (headset) disconnect (keepPlay, required argument), and if so, whether to mute (isMute). If not called, the SDK's default behavior is to stop · Default isMute defaults to false · Mission 11
setKeepPlayVideoOnHeadphoneUnplugged(_ keepPlay: Bool, isMute: Bool = false)

// Read the setting above · Mission 11
isKeepPlayVideoOnHeadPhoneUnplugged() -> Bool

// Whether to mute when the player starts · Default false (sound on) · Mission 11
setMuteWhenPlayStart(_ mute: Bool)

// Whether to play alongside other apps' audio, or pause when other audio plays · Default true (play alongside)
setMixWithOthers(isMixAudio: Bool)

// Directly specify AVAudioSession.Category (iOS-only audio session control)
setAudioSessionCategory(category: AVAudioSession.Category)

// Whether to keep playing when the earphones (headset) disconnect (isKeep), and if so, whether to mute (isMute). Both arguments are required; there is no one-argument form. The disconnect is detected via ACTION_AUDIO_BECOMING_NOISY, so no permission is needed (Android 12+ devices: needs verification) · Mission 11
ShopLive.setKeepPlayVideoOnHeadphoneUnplugged(isKeep: Boolean, isMute: Boolean)

// Whether to auto-resume the video after a call ends. Requires the READ_PHONE_STATE permission · Mission 11
ShopLive.setAutoResumeVideoOnCallEnded(isAutoResume: Boolean)

// Whether to mute when the player starts · Default false (sound on) · Mission 11
ShopLive.setMuteWhenPlayStart(isMuted: Boolean)

// Receive and handle the event yourself when another app takes audio focus (a call, etc.). OnAudioFocusListener has two methods: onGain() · onLoss()
ShopLive.setSoundFocusHandling(listener: OnAudioFocusListener?)

// Whether to play alongside other apps' audio, or pause when other audio plays · Default true (play alongside)
ShopLive.setMixWithOthers(isMixAudio: Boolean)

// Whether to mute when the player starts · Mission 11
ShopLivePlayer().setMuteWhenPlayStart(isMute: bool)

// Whether to play alongside other apps' audio, or pause when other audio plays
ShopLivePlayer().setMixWithOthers(isMixAudio: bool)

// Send a predefined command/payload to the server (e.g. showing a toast over the player)
// For a toast: command "SHOW_LAYER_TOAST", payload keys message (required) · duration (ms) · position (TOP/BOTTOM/CENTER) — based on older docs · needs verification
sendCommandMessage(command: String, payload: [String:Any]?)

// Whether to use local storage
setUsingLocalStorage(_ use: Bool)

// Send the app version (the SDK reads and sends this to the server automatically even without calling it)
setAppVersion(_ appVersion: String)

// Add/remove custom data (key-value) before launching the player
addParameter(key: String, value: String) / removeParameter(key: String)

// Pass UTM parameters along to data insights
setUtmSource(utmSource: String?) / setUtmMedium(utmMedium: String?) / setUtmCampaign(utmCampaign: String?) / setUtmContent(utmContent: String?)

// Send a predefined command/payload to the server
// For a toast: command "SHOW_LAYER_TOAST", payload keys message (required) · duration (ms) · position (TOP/BOTTOM/CENTER) — based on older docs · needs verification
ShopLive.sendCommandMessage(command: String?, payload: Map<String, Any?>)

// Send the app version (the SDK reads and sends this to the server automatically even without calling it)
ShopLive.setAppVersion(appVersion: String)

// Pass UTM parameters along to data insights
ShopLive.setUtmSource / setUtmMedium / setUtmCampaign / setUtmContent(String?)

// Add/remove custom data (key-value) before launching the player
ShopLive.addParameter(key: String, value: String?) / removeParameter(key: String)

// Use a specified URL instead of Shoplive's default Web Landing page (requires prior coordination)
ShopLive.setEndpoint(endpoint: String?)

// Use the specified URL as the Web Landing page (requires prior coordination)
ShopLivePlayer().setEndpoint(endpoint: String?)

// Add/remove custom data (key-value) before launching the player
ShopLivePlayer().addParameter(key: String, value: String?) / removeParameter(key: String)

// Send a predefined command/payload to the server
ShopLivePlayer().sendCommandMessage(command: String, payload: Map<String, dynamic>)

// Pass UTM parameters along to data insights
ShopLiveCommon().setUtmSource / setUtmMedium / setUtmCampaign / setUtmContent(String?)

// Read the current player style (fullScreen / pip / unknown)
style: ShopLive.PresentationStyle

// Read the current player mode (play / preview / none)
playerMode: ShopLive.PlayerMode

// Read the aspect ratio of the currently playing broadcast (portrait / landscape / unknown)
orientationMode: ShopLive.VideoOrientation

// The UIWindow instance the player is displayed in
playerWindow: ShopliveWindow?

// The UIViewController instance the player is displayed in (used when presenting an Alert, etc.)
viewController: ShopLiveViewController?

// Checks whether joining the campaign succeeded. true once ON_SUCCESS_CAMPAIGN_JOIN has arrived through handleReceivedCommand
isSuccessCampaignJoin() -> Bool

// End the currently-watched broadcast
ShopLive.close()

// Whether to also end the broadcast when the root Activity finishes. If false, you must call close() yourself when the app exits · Default true (end together)
ShopLive.setAutoCloseWhenAppDestroyed(isAutoClosed: Boolean)

// Read the current screen state (None / InAppPIP / PIP / Full)
ShopLive.getStatus(): Status

// Whether the preview popup is currently shown
ShopLive.isShowingPreviewPopup(): Boolean

// Checks whether joining the campaign succeeded. true once the player has sent the ON_SUCCESS_CAMPAIGN_JOIN command
ShopLive.isSuccessCampaignJoin(): Boolean

// (Optional) Get the size of · delete the SDK cache. Both are @WorkerThread, so call them in the background. The SDK cleans up automatically when the last Activity is destroyed, so you usually do not need them
ShopLiveCommon.getCacheDirectoryBytes(context: Context): Long
ShopLiveCommon.deleteCacheFiles(ShopLiveCommon.getCacheDirectory(context)): Boolean

// End the currently-watched broadcast
ShopLivePlayer().close()

import ShopLiveSDK
import ShopliveSDKCommon   // needed when you use the request and response types directly

let request = ShopLiveCampaignListRequest(page: 1, size: 20, statuses: [.onair, .ready], order: .descending)

// The callback arrives exactly once on the main thread
let task = ShopLive.API.getCampaigns(request) { result in
    switch result {
    case .success(let response):
        for campaign in response.campaigns {
            if case .onair = campaign.lifecycle.status {
                print(campaign.campaignKey, campaign.title ?? "")
            }
            // If showUserCount is false, do not show the viewer count
            if let metrics = campaign.metrics, metrics.showUserCount {
                print(metrics.userCount ?? 0)
            }
        }
        print(response.hasMore)   // if true, request again with page + 1
    case .failure(let error):
        print(error.codes)        // 9000 · server code · 9900 · 9901
    }
}
// Call task.cancel() when you leave the screen

// async version for iOS 13+. Cancelling the Task also cancels the request and throws CancellationError
let response = try await ShopLive.API.getCampaigns(ShopLiveCampaignListRequest(statuses: [.onair]))

val request = ShopLiveCampaignListRequest(
    page = 1,
    size = 20,
    statuses = listOf(ShopLiveCampaignFilterStatus.ONAIR, ShopLiveCampaignFilterStatus.READY),
    order = ShopLiveCampaignOrder.DESCENDING,
)

// The callback arrives exactly once on the main thread
val handle = ShopLiveCampaigns.getCampaigns(request, object : ShopLiveCampaignListListener {
    override fun onData(response: ShopLiveCampaignListResponse) {
        response.campaigns.forEach { campaign ->
            if (campaign.lifecycle.status == ShopLiveCampaignStatus.OnAir) {
                Log.d("Shoplive", campaign.campaignKey)
            }
            // If showUserCount is false, do not show the viewer count
            val metrics = campaign.metrics
            if (metrics != null && metrics.showUserCount) {
                Log.d("Shoplive", "${metrics.userCount}")
            }
        }
        // If hasMore is true, request again with page + 1
    }

    override fun onError(error: ShopLiveCommonError) {
        Log.e("Shoplive", "${error.code}")   // 9000 · server code · 9900 · 9901 · 10000
    }
})
// Call handle.cancel() when you leave the screen. After cancelling, no callback arrives

// Start playing the broadcast video via campaignKey. Fine-tune behavior via ShopLivePlayerData's keepWindowStateOnPlayExecuted (default true, keeps the running mode), referrer, campaignHandler, brandHandler, and isEnabledVolumeKey · Mission 1
play(data: ShopLivePlayerData)

// Play a preview via campaignKey. campaignKey, referrer, campaignHandler, brandHandler, and isEnabledVolumeKey always apply, but isMuted/resolution (.LIVE/.PREVIEW, default .PREVIEW) only apply when the data argument is actually of type ShopLivePreviewData (ShopLivePlayerData passed as-is is ignored). keepWindowStateOnPlayExecuted isn't read on this path (it's play-only) · Mission 9
preview(data: ShopLivePlayerData, completion: (() -> Void)?)

// End the currently-watched broadcast
close()

// Set the AccessKey to use the Android SDK · Mission 1
ShopLive.setAccessKey(accessKey: String)

// Play the broadcast video via campaignKey. Fine-tune behavior via keepWindowStateOnPlayExecuted (default true) and referrer. intentPlay only builds and returns the Intent object (for when you want to call startActivity yourself) · Mission 1
ShopLive.play(context: Context, data: ShopLivePlayerData) / ShopLive.intentPlay(...): Intent

// Show a popup-style preview via campaignKey. Fine-tune size, margin, mute, close button, swipe-to-close, etc. via ShopLivePreviewData · Mission 9
ShopLive.showPreviewPopup(activity: Activity, data: ShopLivePreviewData)

// When using ShopLivePreviewData.useCustomAction, apply transitionAnimation to the screen transition triggered by tapping the preview
ShopLive.setPreviewTransitionAnimation(activity: Activity, view: View?)

// Hide the currently playing popup-style preview
ShopLive.hidePreviewPopup()

// Start playing the broadcast video via campaignKey · Mission 1
ShopLivePlayer().play(data: ShopLivePlayerData)

// Show a preview via campaignKey · Mission 9
ShopLivePlayer().showPreview(campaignKey: String)

// Set preview display options · Mission 9
ShopLivePlayer().setPreviewOption(data: ShopLivePlayerPreviewData)

// Hide the currently shown preview
ShopLivePlayer().hidePreview()

// Mute the currently playing video
mute()

// Unmute the currently playing video
unmute()

// Mute the player
ShopLive.mute()

// Unmute the player
ShopLive.unmute()

// Initialize ShopLivePlayerPreview state (campaignKey, campaignId, resizeMode, useCloseButton, etc.) · Mission 9
preview.action(.initialize)

// Inject accessKey and campaignKey, then load the player. Replaces the global accessKey with this value · Mission 9
preview.action(.start(accessKey:campaignKey:referrer:))

// Set the mute state · Mission 9
preview.action(.setMuted(Bool))

// Inject a tracking identifier · Mission 9
preview.action(.setReferrer(String?))

// Play / stop / stop and reset · Mission 9
preview.action(.play) / .pause / .stop

// Remove from the parent view and start releasing memory · Mission 9
preview.action(.close)

// Relaunch the broadcast · Mission 9
preview.action(.retry)

// Set the corner radius · Mission 9
preview.action(.setCornerRadius(CGFloat))

// Whether to use the close button. Does nothing in 1.9.0 (close button not supported)
preview.action(.useCloseButton(Bool))

// Whether to allow unmuting via the device volume buttons · Mission 9
preview.action(.setEnabledVolumeKey(isEnabledVolumeKey: Bool))

// How to maintain the video aspect ratio · Default CENTER_CROP · Mission 9
preview.action(.setResizeMode(ShopLiveResizeMode))

// Preview resolution (.LIVE/.PREVIEW) · Default .PREVIEW · Mission 9
preview.action(.setResolutionType(ShopLivePlayerPreviewResolution))

// Closure that subscribes to events, (Result) -> (). Cases: log · handleReceivedCommand · avPlayerTimeControlStatus · avPlayerItemStatus · requestShowAlertController · didChangeCampaignStatus · onError · handleCommand · onSetUserName · handleShare · didChangeCampaignInfo · didChangeVideoDimension · handleShopLivePlayerCampaign · handleShopLivePlayerBrand · Mission 9
preview.resultHandler

// Delegate that receives playback state events (ready · playing · paused · buffering · failed) (ShopLivePlayerPreviewDelegate, weak)
preview.delegate

// Whether it is playing / whether it is muted / AVPlayerItem status / campaignKey, playback state, mute, playback time, campaign, and brand info
preview.isPlaying() / preview.isMuted() / preview.getPlayerItemStatus() / preview.getPlaybackInfo()

// A preview component placed directly in a layout XML · Mission 9
<cloud.shoplive.sdk.ShopLivePreview>

// Pre-set the broadcast key/referrer · Mission 9
setCampaignKey(campaignKey: String?) / setReferrer(referrer: String?)

// Initial preview player setup · Mission 9
initializePlayer()

// Start preview playback (internally runs initializePlayer → prepare → play, in that order) · Mission 9
start() / start(accessKey:campaignKey:referrer:)

// Prepare / play / pause / stop the preview video · Mission 9
prepare() / play() / pause() / stop()

// Release preview resources · Mission 9
release()

// Relaunch the preview · Mission 9
retry()

// Toggle mute state · Mission 9
setMuted(isMuted: Boolean)

// How to maintain the video aspect ratio · Default CENTER_CROP · Mission 9
setResizeMode(resizeMode: ShopLiveResizeMode)

// Auto play/pause following the lifecycle when a LifecycleOwner is registered · Mission 9
setLifecycleObserver(owner: LifecycleOwner)

// Register listeners for preview-start, first-frame-render, click, close, aspect-ratio-change, and playback-state-change events
setOnInitializeListener / setOnRenderedFirstFrameListener / setOnClickListener / setOnCloseListener / setOnDimensionRatioListener / setOnPlaybackStateChanged

// Whether to use a close button · Mission 9
useCloseButton(use: Boolean)

// Whether to allow unmuting via the device volume buttons · Mission 9
setEnabledVolumeKey(isEnabledVolumeKey: Boolean)

// Preview resolution (LIVE/PREVIEW) · Default PREVIEW · Mission 9
setResolutionType(resolutionType: ShopLivePreviewResolutionType)

// Whether to show an image after the preview ends · Default true
setPostCampaignImageVisible(isPostCampaignImageVisible: Boolean)

// Release preview memory · Mission 9
destroy()

// Retrieve campaignKey, playback state, mute, playback time, campaign, and brand info all at once
getPlaybackInfo(): ShopLivePreviewPlaybackInfo