import com.amazon.device.iap.PurchasingService; //导入依赖的package包/类
@Override
public Inventory queryInventory(boolean querySkuDetails, List<String> moreSkus) throws IabException {
    Log.d(TAG,"queryInventory");


    try {
        mInventory = new Inventory();
        Log.d(TAG,"getPurchaseUpdates");

        synchronized(mLock) {
            PurchasingService.getPurchaseUpdates(true);
            mLock.wait(10000);
        }

        Log.d(TAG,"getProductData");
        synchronized(mLock) {
            PurchasingService.getProductData(new HashSet<String>(moreSkus));
            mLock.wait(10000);
        }

    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return mInventory;
}
 

import com.amazon.device.iap.PurchasingService; //导入依赖的package包/类
@Override
public void install (final PurchaseObserver observer, PurchaseManagerConfig config, boolean autoFetchInformation) {
	this.observer = observer;
	this.config = config;
	
	// --- copy all available products to the list of productIdentifiers
	int offerSize = config.getOfferCount();
	productIdentifiers = new HashSet<String>(offerSize);
	for (int z = 0; z < config.getOfferCount(); z++) {
		productIdentifiers.add(config.getOffer(z).getIdentifierForStore(storeName()));
	}
	
	PurchasingService.registerListener(activity.getApplicationContext(), this);
	
	// PurchasingService.IS_SANDBOX_MODE returns a boolean value. 
	// Use this boolean value to check whether your app is running in test mode under the App Tester 
	// or in the live production environment.
	showMessage(LOGTYPELOG, "Amazon IAP: sandbox mode is:" + PurchasingService.IS_SANDBOX_MODE);
	
	observer.handleInstall();
	
	PurchasingService.getUserData();
	
	PurchasingService.getProductData(productIdentifiers);
}
 

import com.amazon.device.iap.PurchasingService; //导入依赖的package包/类
@Override
public void startSetup(OnIabSetupFinishedListener listener) {
    mOnIabSetupFinishedListener = listener;
    if (mPurchasingObserver == null) {
        mPurchasingObserver = new PurchasingObserver();
    }
    mHandler.removeMessages(MSG_SETUP_TIMEOUT);
    mHasSetupTimeout = false;
    mHandler.sendEmptyMessageAtTime(MSG_SETUP_TIMEOUT, SETUP_TIMEOUT);

    PurchasingService.registerListener(ArchosUtils.getGlobalContext(), mPurchasingObserver);
    PurchasingService.getUserData();
}
 

import com.amazon.device.iap.PurchasingService; //导入依赖的package包/类
@Override
public void launchPurchaseFlow(Activity act, String sku, int requestCode, OnIabPurchaseFinishedListener listener, String extraData) {
    mExtraData = extraData;
    mLastOperationSKU = sku;
    mOnIabPurchaseFinishedListener = listener;
    PurchasingService.purchase(sku);
}
 

import com.amazon.device.iap.PurchasingService; //导入依赖的package包/类
@Override
public void init(String key) {
    mAmazonBillingListener = new AmazonBillingListener(this);
    PurchasingService.registerListener(context, mAmazonBillingListener);

    final Set<String> productSkus = new HashSet<>(iapkeys);
    PurchasingService.getProductData(productSkus);

    PurchasingService.getPurchaseUpdates(true);
}
 

import com.amazon.device.iap.PurchasingService; //导入依赖的package包/类
@Override
public void purchase(final String productId, int quantity, PurchaseCallback callback) {

    dispatchCallback(new Runnable() {
        @Override
        public void run() {
            notifyPurchaseStarted(productId);
        }
    });

    RequestId request = PurchasingService.purchase(productId);
    mProductIds.put(request, productId);
    mPurchaseCallbacks.put(request, callback);
}
 

import com.amazon.device.iap.PurchasingService; //导入依赖的package包/类
/**
  * Method to handle receipts
  * 
  * @param requestId
  * @param receipt
  * @param userData
  */
 public void handleReceipt(final String requestId, final Receipt receipt, final UserData userData) {

 	showMessage(LOGTYPELOG,  "Handle receipt: requestId (" + requestId
     + ") receipt: "
     + receipt
     + ")");
     
   // convert receipt to transaction
     Transaction trans = AmazonTransactionUtils.convertReceiptToTransaction(1, requestId, receipt, userData);	// provides cancleState also
			
 	switch (receipt.getProductType()) {
             
     case CONSUMABLE:
// inform the listener
observer.handlePurchase(trans);
         // Automatically consume item
     	PurchasingService.notifyFulfillment(receipt.getReceiptId(), FulfillmentResult.FULFILLED);
         break;
         
     case ENTITLED:
// inform the listener
observer.handlePurchase(trans);
         break;
         
     case SUBSCRIPTION:
         // TODO: check subscription sample for how to handle consumable purchases
         break;
     }
 }
 

import com.amazon.device.iap.PurchasingService; //导入依赖的package包/类
@SuppressWarnings("PMD.NonThreadSafeSingleton")
public static AmazonBillingHelper getInstance(@NonNull final Context context) {
    if (instance == null) {
        instance = new AmazonBillingHelper();
        PurchasingService.registerListener(context, instance);
    }
    return instance;
}
 

import com.amazon.device.iap.PurchasingService; //导入依赖的package包/类
/**
 * Requests user data form Amazon SDK.
 *
 * @return User data if received withing {@link #USER_DATA_TIMEOUT}, null otherwise.
 */
@Nullable
UserData getUserData() {
    final SyncedReference<UserData> syncUserData = new SyncedReference<>();
    try {
        this.syncUserData = syncUserData;
        PurchasingService.getUserData();
        return syncUserData.get(USER_DATA_TIMEOUT);
    } finally {
        this.syncUserData = null;
    }
}
 

import com.amazon.device.iap.PurchasingService; //导入依赖的package包/类
/**
 * Tries to guess appropriate error code.
 *
 * @return Most suitable status.
 */
protected Status handleFailure() {
    // Unfortunately Amazon doesn't report a reason for error
    if (!PurchasingService.IS_SANDBOX_MODE && !OPFUtils.isConnected(context)) {
        return SERVICE_UNAVAILABLE;
    }

    return UNKNOWN_ERROR;
}
 

import com.amazon.device.iap.PurchasingService; //导入依赖的package包/类
@Override
public boolean isAvailable() {
    final PackageManager packageManager = context.getPackageManager();
    for (final PackageInfo info : packageManager.getInstalledPackages(0)) {
        if (PATTERN_STORE_PACKAGE.matcher(info.packageName).matches()) {
            // Check sdk tester package if app is in sandbox mode.
            return !PurchasingService.IS_SANDBOX_MODE
                    || OPFUtils.isInstalled(context, TESTER_PACKAGE);
        }
    }
    return false;
}
 

import com.amazon.device.iap.PurchasingService; //导入依赖的package包/类
@Override
public void consume(@NonNull final ConsumeRequest request) {
    final Purchase purchase = request.getPurchase();
    final String token = purchase.getToken();
    if (!TextUtils.isEmpty(token)) {
        PurchasingService.notifyFulfillment(token, FulfillmentResult.FULFILLED);
        postResponse(new ConsumeResponse(SUCCESS, getName(), purchase));
    } else {
        postEmptyResponse(request, ITEM_UNAVAILABLE);
    }
}
 

import com.amazon.device.iap.PurchasingService; //导入依赖的package包/类
/**
 * see parent
 */
@Override
protected void startSetupInner() {
    if (mPurchasingObserver == null) {
        mPurchasingObserver = new PurchasingObserver();
    }
    PurchasingService.registerListener(SoomlaApp.getAppContext(), mPurchasingObserver);

    PurchasingService.getUserData();
}
 

import com.amazon.device.iap.PurchasingService; //导入依赖的package包/类
/**
 * see parent
 */
@Override
protected void fetchSkusDetailsAsyncInner(List<String> skus) {
    if (skus == null || skus.isEmpty()){
        SoomlaUtils.LogDebug(TAG, "skus is null or empty, nothing to fetch.");
        // Finish the fetch so it doesn't get stuck
        AmazonIabHelper.this.fetchSkusDetailsSuccess(new IabInventory());
        return;
    }

    PurchasingService.getProductData(new HashSet<String>(skus));
}
 

import com.amazon.device.iap.PurchasingService; //导入依赖的package包/类
/**
 * @param listener - is triggered when {@link #onUserDataResponse(UserDataResponse)} happens
 */
@Override
public void startSetup(IabHelper.OnIabSetupFinishedListener listener) {
    this.setupListener = listener;
    PurchasingService.registerListener(context, this);
    PurchasingService.getUserData();
}
 

import com.amazon.device.iap.PurchasingService; //导入依赖的package包/类
@Override
public void onPurchaseUpdatesResponse(final PurchaseUpdatesResponse purchaseUpdatesResponse) {
    final PurchaseUpdatesResponse.RequestStatus requestStatus = purchaseUpdatesResponse.getRequestStatus();
    final RequestId requestId = purchaseUpdatesResponse.getRequestId();
    Logger.d("onPurchaseUpdatesResponse() reqStatus: ", requestStatus,
            "reqId: ", requestId);

    switch (requestStatus) {
        case SUCCESSFUL:
            for (final String sku : inventory.getAllOwnedSkus()) {
                inventory.erasePurchase(sku);
            }
            final UserData userData = purchaseUpdatesResponse.getUserData();
            final String userId = userData.getUserId();
            if (!userId.equals(currentUserId)) {
                Logger.w("onPurchaseUpdatesResponse() Current UserId: ", currentUserId,
                        ", purchase UserId: ", userId);
                break;
            }
            for (final Receipt receipt : purchaseUpdatesResponse.getReceipts()) {
                inventory.addPurchase(getPurchase(receipt));
            }
            if (purchaseUpdatesResponse.hasMore()) {
                PurchasingService.getPurchaseUpdates(false);
                Logger.d("Initiating Another Purchase Updates with offset: ");
                return;
            }
            break;
        case FAILED:
            break;
    }
    final CountDownLatch countDownLatch = inventoryLatchQueue.poll();
    if (countDownLatch != null) {
        countDownLatch.countDown();
    }
}
 

import com.amazon.device.iap.PurchasingService; //导入依赖的package包/类
@Override
public void launchPurchaseFlow(
        final Activity activity,
        final String sku,
        final String itemType,
        final int requestCode,
        final IabHelper.OnIabPurchaseFinishedListener listener,
        final String extraData) {
    final RequestId requestId = PurchasingService.purchase(sku);
    requestSkuMap.put(requestId, sku);
    requestListeners.put(requestId, listener);
}
 

import com.amazon.device.iap.PurchasingService; //导入依赖的package包/类
@Override
public void buy(Activity activity, String sku, int id) {
    PurchasingService.purchase(sku);
}
 

import com.amazon.device.iap.PurchasingService; //导入依赖的package包/类
@Override
public void subscribe(Activity activity, String sku, int id) {
    PurchasingService.purchase(sku);
}
 

import com.amazon.device.iap.PurchasingService; //导入依赖的package包/类
AmazonBillingListener(AmazonBillingService amazonBillingService) {
    this.amazonBillingService = amazonBillingService;
    logDebug("IS_SANDBOX_MODE:" + PurchasingService.IS_SANDBOX_MODE);
}