Cppcheck report - Fission: gameModules/gfGameCore/components/gfIPaywallGui.cpp

#include "gfIPaywallGui.h"

#if defined fsInAppPurchaseProcess

#include <fsCore/fsIFile.h>
#include <fsCore/fsSColour.h>

#include <fsRenderer/src/fsCBrushManager.h>
#include <fsAppCore/src/components/gui/elements/fsCButtonComponent.h>
#include <fsAppCore/src/components/gui/fsCConfirmBoxGui.h>
#include <fsRenderer/src/components/fsCSpriteComponent.h>
#include <fsRenderer/src/components/fsITextSpriteComponent.h>
#include <fsAppCore/src/fsILevelBasedAppCoreMain.h>
#include <fsAppCore/src/fsCAppCoreMain.h>
#include <fsAppCore/src/fsCLocalisedStrings.h>
#include <fsAppCore/src/fsCProfileManager.h>
#if defined fsInAppPurchase
#include <fsPlatform/assets/fsAssetFactory.h>
#include <fsPlatform/iap/fsIapFactory.h>
#endif

#include <gfGameCore/components/gfCPaywallTransaction.h>
#include <gfGameCore/src/gfCInGameAdsManager.h>
#include <fsAppCore/src/components/gui/elements/fsCModalGuiComponent.h>

const fsStr gfIPaywallGui::mUnknownErrorId( "marketErrorUnknown" );
const fsStr gfIPaywallGui::mBuyingDisabledErrorId( "marketErrorBuyingDisabledIOS" );
const fsS32 gfIPaywallGui::mRewardAdTimeoutMS(15000);
fsBool gfIPaywallGui::mRewardUnlockMode(false);
fsBool gfIPaywallGui::mRewardAdGranted(false);

const fsCUniqueId gfIPaywallGui::mTypeId( "fsIPaywallGui" );

void gfIPaywallGui::rewardUnlockModeSet(fsBool pEnabled)
{
    mRewardUnlockMode = pEnabled;
}

fsBool gfIPaywallGui::rewardUnlockModeGet()
{
    return mRewardUnlockMode;
}

void gfIPaywallGui::rewardAdGrantedNotify()
{
    mRewardAdGranted = true;
}

const fsStr& gfIPaywallGui::paywallItemNameGet() const
{
    static const fsStr emptyName;
    return emptyName;
}

fsCResourceName gfIPaywallGui::guiFileGet()
{
    return fsCResourceName(
        mRewardUnlockMode ? "gui/paywallGui/paywallGui.txt" : "gui/buyNowGui/buyNowGui.txt",
        fsCResourceName::eRES_LOCATION_ASSETS);
}

void gfIPaywallGui::busyScreenCreate()
{
    auto busyScreenFilename =  fsCResourceName("gui/buyNowGui/busy.txt", fsCResourceName::eRES_LOCATION_ASSETS);
	auto busyScreen = fsIGuiComponent::guiCreateFromFile(busyScreenFilename, parentGet());
}

fsStr gfIPaywallGui::screenshotPathBaseGet() const
{
    return mRewardUnlockMode ? fsStr("gui/paywallGui/screen") : fsStr("gui/buyNowGui/screen");
}

fsStr gfIPaywallGui::screenshotPathGet(fsS32 pScreenshotIndex) const
{
	const fsStr pathBase = screenshotPathBaseGet() + fsStr(pScreenshotIndex);
	const fsStr pngPath = pathBase + ".png";
	if (fsIFile::fileExistsGet(fsCResourceName(pngPath, fsCResourceName::eRES_LOCATION_ASSETS)))
	{
		return pngPath;
	}

	const fsStr jpgPath = pathBase + ".jpg";
	if (fsIFile::fileExistsGet(fsCResourceName(jpgPath, fsCResourceName::eRES_LOCATION_ASSETS)))
	{
		return jpgPath;
	}

	return fsStr();
}

void gfIPaywallGui::screenshotsInitialise()
{
	mMainScreenshot = parentGet()->childFind("paywallScreenshotMain");
	mFadeScreenshot = parentGet()->childFind("paywallScreenshotFade");

	if (mMainScreenshot)
	{
		fsBool fileExists = true;
		fsStr screenshotFn;

		while (fileExists)
		{
			screenshotFn = screenshotPathGet(++mScreenshotCount);
			fileExists = !screenshotFn.emptyGet();
			if (!fileExists)
			{
				--mScreenshotCount;
			}
		}

		if (mScreenshotCount == 0)
		{
			mMainScreenshot->visibleSet(false);
			mFadeScreenshot->visibleSet(false);
		}
		else
		{
			screenshotChange();
		}
	}
}

void gfIPaywallGui::entitySpriteChange(fsCEntity* const pEnt, const fsStr& pFilename)
{
	fsISpriteComponent* const sprtCmp = pEnt->spriteComponentGet();
	sprtCmp->brushSet(fsCBrushManager::instanceGet()->get(
		fsCResourceName(pFilename, fsCResourceName::eRES_LOCATION_ASSETS), false));
}

void gfIPaywallGui::screenshotChange()
{
	fsStr screenshotFn;
	screenshotFn = screenshotPathGet(mCurrScreenshot);
	entitySpriteChange(mMainScreenshot, screenshotFn);

	if (mScreenshotCount > 1)
	{
		if (++mCurrScreenshot > mScreenshotCount)
		{
			mCurrScreenshot = 1;
		}
		screenshotFn = screenshotPathGet(mCurrScreenshot);
		entitySpriteChange(mFadeScreenshot, screenshotFn);
		fsISpriteComponent* const sprtCmp = mFadeScreenshot->spriteComponentGet();
		sprtCmp->colourSet(fsSColour(1.0f, 1.0f, 1.0f, 0.0f));
	}
}

void gfIPaywallGui::screenshotsUpdate(fsS32 pDeltaMS)
{
	mElapsedTime += pDeltaMS;
	if (mElapsedTime > 3000)
	{
		screenshotChange();
		mElapsedTime = 0;
	}
	else if (mElapsedTime > 2000)
	{
		fsF32 alpha = static_cast<fsS32>(mElapsedTime - 2000) / 1000.0f;
		auto* const sprtCmp = mFadeScreenshot->spriteComponentGet();
		sprtCmp->colourSet(fsSColour(1.0f, 1.0f, 1.0f, alpha));
	}
}

void gfIPaywallGui::updateDo(fsS32 pDeltaMS)
{
	if (mAwaitingRewardAd)
	{
		rewardAdWaitUpdate(pDeltaMS);
	}

	if (mTransaction)
	{
		if (mTransaction->update(pDeltaMS))
		{
			transactionDestroy();
			errorDisplay("connectionTimeOut");
		}
	}
	else if (mScreenshotCount > 1)
	{
		screenshotsUpdate(pDeltaMS);
	}

	fsIGuiComponent::updateDo(pDeltaMS);
}

#if defined fsInAppPurchase
void gfIPaywallGui::productPurchase()
{
	mTransaction->actionSet(&gfIPaywallGui::purchaseMadeHandle);
    mAwaitingPurchaseCompletion = true;
    if (mIapService)
    {
        mIapService->purchaseReadyProduct();
    }
}
#endif

fsCEntity* const gfIPaywallGui::paywallParentEntityGet()
{  // callback safe check as the parent entity could have been destroyed while the callback waited to be triggered
	return dynamic_cast<fsCEntity*>(fsCAppCoreMain::instanceGet()->sceneGet()->entityNamed("paywallMenuWindow"));
}

#if defined fsInAppPurchase
void gfIPaywallGui::onProductValidated(const fsIapProductInfo& productInfo)
{
	if (paywallParentEntityGet())
	{
        (void)productInfo;
        if (mAwaitingProductQuery)
        {
            mAwaitingProductQuery = false;
            transactionFinalise();
        }
	}
}

void gfIPaywallGui::transactionFinalise()
{
	if (mTransaction)
	{
		mTransaction->action(this);
	}
}

void gfIPaywallGui::purchaseMadeHandle()
{
	transactionDestroy();
    mRewardUnlockMode = false;

	fsCProfileManager::instanceGet()->fullGamePurchasedHandle();
	if (fsCEntity* const mainMenuEnt = guiParentGetFromComponent(this)->parentGet()->childFind("MainMenuBuyNowButton"))
	{
		mainMenuEnt->visibleSet(false);
	}

	parentGet()->destroy();
	mElapsedTime = 0;
}

void gfIPaywallGui::purchaseErrorHandle(const fsStr& pErrorId)
{
 	if (!pErrorId.emptyGet())
 	{
 		errorDisplay(pErrorId);
        transactionDestroy();
 	}
}

void gfIPaywallGui::onProductInvalid(const std::string& productId)
{
    (void)productId;
    if (!paywallParentEntityGet())
    {
        return;
    }

    mAwaitingProductQuery = false;
    purchaseErrorHandle(mUnknownErrorId);
}

void gfIPaywallGui::onPurchaseCompleted(const std::string& productId)
{
    (void)productId;
    if (!paywallParentEntityGet())
    {
        return;
    }

    if (mAwaitingPurchaseCompletion)
    {
        mAwaitingPurchaseCompletion = false;
        if (mAssetService)
        {
            fsAssetRequest request;
            request.tag = paywallItemNameGet().utf8Get();
            mAssetService->fetch(request);
        }
        transactionFinalise();
    }
}

void gfIPaywallGui::onPurchaseFailed(const std::string& productId, const std::string& reason)
{
    (void)productId;
    (void)reason;
    if (!paywallParentEntityGet())
    {
        return;
    }

    purchaseErrorHandle(mUnknownErrorId);
}

void gfIPaywallGui::onPurchaseCancelled(const std::string& productId)
{
    (void)productId;
    if (!paywallParentEntityGet())
    {
        return;
    }

    transactionDestroy();
}

void gfIPaywallGui::onFetchSucceeded(const std::string& tag)
{
    (void)tag;
}

void gfIPaywallGui::onFetchFailed(const std::string& tag)
{
    (void)tag;
}
#endif

void gfIPaywallGui::initiateUnlockAttempt()
{
#if defined fsInAppPurchase
    fsBool startResult = (nullptr != mIapService.get());
    if (startResult)<--- First condition
    {
        mAwaitingProductQuery = true;
        mTransaction = new fsCPaywallTransaction(&gfIPaywallGui::productPurchase);
        mIapService->queryProduct(paywallItemNameGet().utf8Get());
    }
	if (startResult)<--- Second condition
	{
		busyScreenCreate();
	}
#else
    errorDisplay(mBuyingDisabledErrorId);
#endif
}

fsBool gfIPaywallGui::onButtonClicked(fsCButtonComponent* pButtonComp)
{
	const fsStr& btnName = pButtonComp->parentGet()->nameGet();
	if ("paywallBuyNowButton" == btnName)
	{
		if (!mTransaction)
		{
			initiateUnlockAttempt();
		}
		return true;
	}
	else if ("paywallwatchVideoButton" == btnName)
	{
		rewardAdRequest();
		return true;
	}
	else if ("paywallLaterButton" == btnName)
	{
		mRewardUnlockMode = false;
		if (fsILevelBasedAppCoreMain::instanceGet()->sceneRootGet())
		{// In game.
			fsILevelBasedAppCoreMain::instanceGet()->quitToMenuSet();
		}
		else
		{
			parentGet()->destroy();
		}
		return true;
	}
	return false;
}

void gfIPaywallGui::transactionDestroy()
{
#if defined fsInAppPurchase
    mAwaitingProductQuery = false;
    mAwaitingPurchaseCompletion = false;
#endif

	if (mTransaction)
	{
		busyOverlayDestroy();
		delete mTransaction;
		mTransaction = nullptr;
	}
}

void gfIPaywallGui::rewardAdRequest()
{
	gfCInGameAdsManager& adsManager = gfCInGameAdsManager::instanceGet();
	// mTransaction: a purchase query is already in flight with its own busy
	// overlay. Starting the reward flow on top of it would fade to black over a
	// live purchase and leave two completion paths racing for the same unlock.
	if (mAwaitingRewardAd || mTransaction || adsManager.transitionBlocked()
		|| !adsManager.rewardUnlockAvailable())
	{
		return;
	}

	mAwaitingRewardAd = true;
	mRewardAdWaitMS = 0;
	mRewardAdGranted = false;
	// Fade to black behind the video, matching how a boundary interstitial is
	// shown. Without this the paywall is still up when the video closes, so the
	// player is dropped back onto it for the length of the following fade. The
	// fade is the feedback here - a busy overlay would only be visible for the
	// fade itself and is hidden completely once the screen is black.
	fsILevelBasedAppCoreMain::instanceGet()->fadeOut();
	adsManager.rewardUnlockAdShow();
}

void gfIPaywallGui::rewardAdWaitEnd(fsBool pFadeBackIn)
{
	mAwaitingRewardAd = false;
	if (pFadeBackIn)
	{	// We faded out for the video, so fade back in or the player is left
		// staring at a black screen with the paywall hidden behind it.
		fsILevelBasedAppCoreMain::instanceGet()->fadeIn();
	}
}

void gfIPaywallGui::rewardAdWaitUpdate(fsS32 pDeltaMS)
{
	gfCInGameAdsManager& adsManager = gfCInGameAdsManager::instanceGet();
	if (mRewardAdGranted)
	{	// Unlock granted: the level is already fading out to load the next one
		// and will destroy this gui once the screen is black. Fading back in
		// here would fight that fade and strand the player on the paywall.
		mRewardAdGranted = false;
		rewardAdWaitEnd(false);
		return;
	}

	if (!adsManager.transitionBlocked())
	{	// The reward flow finished without granting the unlock (e.g. the ad
		// was closed early), so bring the paywall back.
		rewardAdWaitEnd(true);
		return;
	}

	mRewardAdWaitMS += pDeltaMS;
	if (mRewardAdWaitMS > mRewardAdTimeoutMS && !adsManager.adActive())
	{	// No supplier ever called back; abandon the attempt so the player can
		// retry rather than sitting on a black screen.
		adsManager.rewardUnlockAdCancel();
		rewardAdWaitEnd(true);
	}
}

void gfIPaywallGui::busyOverlayDestroy()
{
	if (fsCEntity* const busyEnt = parentGet()->childFind("paywallBusy"))
	{
		busyEnt->destroy();
	}
}

void gfIPaywallGui::errorDisplay(const fsStr& pErrorStringId)
{
	fsCConfirmBoxGui::okBoxCreate(parentGet(), fsCLocalisedStrings::localisedStringGet(pErrorStringId));
}

void gfIPaywallGui::initialiseFromVariableTableDo(const fsCVariableTable& pVars)
{
	screenshotsInitialise();
	fsIGuiComponent::initialiseFromVariableTableDo(pVars);
}

gfIPaywallGui::gfIPaywallGui(fsCEntity* const pParent) :
fsIGuiComponent(pParent),
mTransaction(nullptr),
mMainScreenshot(nullptr),
mFadeScreenshot(nullptr),
mScreenshotCount(0),
mCurrScreenshot(1),
mElapsedTime(0),
mAwaitingRewardAd(false),
mRewardAdWaitMS(0)
#if defined fsInAppPurchase
, mIapService(fsIapServiceCreate(this)),
mAssetService(fsAssetServiceCreate()),
mAwaitingProductQuery(false),
mAwaitingPurchaseCompletion(false)
#endif
{
#if defined fsInAppPurchase
    if (mAssetService)
    {
        mAssetService->setObserver(this);
    }
#endif
}

gfIPaywallGui::~gfIPaywallGui()
{
    mRewardUnlockMode = false;
    mRewardAdGranted = false;

    if (mAwaitingRewardAd)
    {	// Paywall going away with a request still in flight (e.g. "later"
        // pressed): drop it so a stale pending request can't block later ads.
        gfCInGameAdsManager::instanceGet().rewardUnlockAdCancel();
    }

#if defined fsInAppPurchase
    if (mAssetService)
    {
        mAssetService->shutdown();
    }

    if (mIapService)
    {
        mIapService->shutdown();
    }
#endif
}

#endif