Class CommerceKitModuleWearable Only

Example

let module: CommerceKitModule = require("LensStudio:CommerceKitModule");

// Declare client variable and purchase status cache
let client: Commerce.Client;
let purchaseStatusCache: Map<string, Commerce.PurchaseState> = new Map();

// Helper function to print important product fields manually
function printProductDetails(product: any) {
  print(`  ID: ${product.id}, Name: ${product.displayName}, Price: ${product.price?.displayPrice || product.price?.price}`);
}

// Function to update the purchase status cache from purchase history
async function updatePurchaseStatusCache(productIds: string[]) {
  try {
    const purchaseHistory = await client.queryPurchaseHistory();

    productIds.forEach(productId => {
      const purchase = purchaseHistory.find((p: any) => p.productId === productId);
      if (purchase) {
        purchaseStatusCache.set(productId, purchase.purchaseState);
        print("Purchase state of " + productId + ", purchased:" + (purchase.purchaseState === Commerce.PurchaseState.Purchased));
      } else {
        purchaseStatusCache.set(productId, Commerce.PurchaseState.Unset);
        print("No purchase record found for product ID: " + productId);
      }
    });
  } catch (error) {
    print('Error updating purchase status cache: ' + error);
  }
}

// Function to handle processing of a successful purchase.
function processPurchase(purchase: Commerce.Purchase) {
  print(`Processing purchase for product: ${purchase.productId}, state: ${purchase.purchaseState}`);

  // Only acknowledge purchases that are in Purchased state
  if (purchase.purchaseState === Commerce.PurchaseState.Purchased || purchase.purchaseState === Commerce.PurchaseState.Pending) {
    client.acknowledgePurchase(purchase.token).then(() => {
      print(`Purchase for ${purchase.productId} acknowledged.`);
    }).catch(error => {
      print('Failed to acknowledge purchase: ' + error);
    });
  } else {
    print(`Purchase for ${purchase.productId} is not in Purchased state, skipping acknowledgment.`);
  }
}

// Function to handle purchase status updates.
const onPurchasesUpdated = (result: Commerce.PurchaseResult, purchases: Commerce.Purchase[]) => {
  if (result.responseCode === Commerce.ResponseCode.Success && purchases.length > 0) {
    purchases.forEach(purchase => {
      print(`Successfully purchased: ${purchase.productId}`);
      processPurchase(purchase);
    });
  } else if (result.responseCode === Commerce.ResponseCode.UserCanceled) {
    print('Purchase was cancelled.');
  } else {
    print('Purchase failed or was not acknowledged.');
  }

  // Update the status cache after processing purchases
  const productIds = ['com.snap.product1', 'com.snap.product2', 'com.snap.product3', 'com.snap.newProduct1'];
  updatePurchaseStatusCache(productIds);
};

// Scenario: Query available product details.
async function demoQueryProducts() {
  try {
    const productIds = ['com.snap.product1', 'com.snap.product2', 'com.snap.product3'];
    const products = await client.queryProductDetails(productIds);

    if (products && products.length > 0) {
      print('Available products:');
      products.forEach((product: any) => {
        printProductDetails(product);
      });
    } else {
      print('No products found');
    }
  } catch (error) {
    print('Error during product query: ' + error);
  }
}

// Scenario: Check purchase status for a specific product (using cache).
function demoCheckPurchaseStatus(productId: string) {
  const purchaseState = purchaseStatusCache.get(productId);

  if (purchaseState === undefined) {
    print(`Product '${productId}' not found in cache. Initialize cache first.`);
    return;
  }

  switch (purchaseState) {
    case Commerce.PurchaseState.Purchased:
      print(`Product '${productId}' has been purchased.`);
      break;
    case Commerce.PurchaseState.Unset:
      print(`Product '${productId}' has not been purchased.`);
      break;
    default:
      print(`Product '${productId}' purchase state: ${purchaseState}`);
  }
}

// Scenario: Launch purchase flow for a product.
async function demoLaunchPurchaseFlow(productId: string) {
  try {
    const purchaseResult = await client.launchPurchaseFlow(productId);
    print(`Purchase flow completed with response code: ${purchaseResult.responseCode}`);

    if (purchaseResult.responseCode === Commerce.ResponseCode.Success) {
      print('Purchase flow was launched successfully.');
    }
  } catch (error) {
    print('Error in purchase process: ' + error);
  }
}

// Example invocation of the various scenarios
async function example() {
  try {
    // Initialize the commerce client
    print('Initializing commerce client...');
    const clientOptions = new Commerce.ClientOptions(onPurchasesUpdated);
    client = module.createClient(clientOptions);

    await client.startConnection();
    print('Connected to commerce service.');

    const productIds = ['com.snap.product1', 'com.snap.product2', 'com.snap.product3', 'com.snap.newProduct1'];
    await updatePurchaseStatusCache(productIds);

    await demoQueryProducts();
    demoCheckPurchaseStatus('com.snap.product1'); // Check from cache (no query needed)
    await demoLaunchPurchaseFlow('com.snap.newProduct1'); // Launch purchase flow
    demoCheckPurchaseStatus('com.snap.newProduct1'); // Check from cache (automatically updated via callback)
  } catch (error) {
    print('Error in commerce operations: ' + error);
  } finally {
    if (client) {
      client.endConnection();
      print('Commerce client connection closed.');
    }
  }
}

example();
Copy