apps-sdk 2.1.2 → 2.1.4

package/src/libraries/Rating.js

@@ -1,65 +1,327 @@
 import * as StoreReview from 'expo-store-review';
+import { Platform } from 'react-native';
 import Storage from './Storage';
 
-const REVIEW_INTERVAL = 1000 * 60 * 60 * 24 * 7; // 7 días
+// ---------------------------------------------------------------------------
+// Storage keys
+// ---------------------------------------------------------------------------
+const STORAGE_KEYS = {
+    FIRST_AI_INTERACTION_DONE:    'RATING_FIRST_AI_INTERACTION_DONE',
+    USER_SENTIMENT_POSITIVE:      'RATING_USER_SENTIMENT_POSITIVE',
+    RATING_ATTEMPTS_COUNT:        'RATING_ATTEMPTS_COUNT',
+    FEEDBACK_SUBMITTED:           'RATING_FEEDBACK_SUBMITTED',
+    LAST_RATING_PROMPT_DATE:      'RATING_LAST_RATING_PROMPT_DATE',
+    DOWNLOAD_SHARE_PROMPT_SHOWN:  'RATING_DOWNLOAD_SHARE_PROMPT_SHOWN',
+    LOW_CREDITS_PROMPT_SHOWN:     'RATING_LOW_CREDITS_PROMPT_SHOWN',
+};
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const MAX_RATING_ATTEMPTS  = 2;      // Max native rating prompts shown lifetime
+const RATING_DELAY_MS      = 5000;   // Delay before showing prompt after AI response
+const LOW_CREDITS_THRESHOLD = 3;     // Credits level considered "low"
+
+// ---------------------------------------------------------------------------
+// Rating class
+// ---------------------------------------------------------------------------
 class Rating {
-    showRatingDialog = async (force = false) => {
+
+    // In-memory state (also persisted in storage)
+    _hasCompletedFirstInteraction = false;
+    _isShowingPrompt = false;
+
+    // UI callbacks — injected via configure()
+    _onShowSentimentPrompt = null;  // (source: string) => void
+    _onShowFeedbackForm    = null;  // () => void
+    _onTrackEvent          = null;  // (eventName: string, props: object) => void
+    _onSubmitFeedback      = null;  // (text: string) => Promise<void>  (optional app-level hook)
+
+    // -----------------------------------------------------------------------
+    // configure — call once on app startup (after initialize) with UI hooks
+    // -----------------------------------------------------------------------
+    configure = ({
+        onShowSentimentPrompt,
+        onShowFeedbackForm,
+        onTrackEvent,
+        onSubmitFeedback,
+    } = {}) => {
+        if (onShowSentimentPrompt) this._onShowSentimentPrompt = onShowSentimentPrompt;
+        if (onShowFeedbackForm)    this._onShowFeedbackForm    = onShowFeedbackForm;
+        if (onTrackEvent)          this._onTrackEvent          = onTrackEvent;
+        if (onSubmitFeedback)      this._onSubmitFeedback      = onSubmitFeedback;
+    }
+
+    // -----------------------------------------------------------------------
+    // initialize — load persisted state from storage
+    // -----------------------------------------------------------------------
+    initialize = async () => {
         try {
-            if (force || (await this.requestReviewIfNeeded())) {
-                if (await StoreReview.hasAction()) {
-                    if (await StoreReview.isAvailableAsync()) {
-                        await StoreReview.requestReview();
-                        return {
-                            success: true,
-                            shown: true,
-                            message: 'Review dialog shown successfully'
-                        };
-                    } else {
-                        return {
-                            success: false,
-                            shown: false,
-                            blocked: true,
-                            message: 'Review dialog not available (possibly blocked by OS)'
-                        };
-                    }
-                } else {
-                    return {
-                        success: false,
-                        shown: false,
-                        blocked: true,
-                        message: 'Store review not supported on this device'
-                    };
+            const hasInteracted = await Storage.getData(STORAGE_KEYS.FIRST_AI_INTERACTION_DONE);
+            this._hasCompletedFirstInteraction = hasInteracted === 'true';
+        } catch (error) {
+            console.error('[RatingFlow] Failed to initialize:', error);
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // onAIInteractionSuccess
+    // Called after every successful AI response.
+    // @param isUserInitiated — true if the user explicitly triggered the action
+    // -----------------------------------------------------------------------
+    onAIInteractionSuccess = async (isUserInitiated = false) => {
+        if (this._isShowingPrompt) return;
+
+        if (!this._hasCompletedFirstInteraction) {
+            // Only show on user-initiated interactions (not auto-generated intro/welcome)
+            if (!isUserInitiated) return;
+
+            await Storage.storeData(STORAGE_KEYS.FIRST_AI_INTERACTION_DONE, 'true');
+            this._hasCompletedFirstInteraction = true;
+
+            setTimeout(async () => {
+                const canShow = await this._checkBasicEligibility();
+                if (canShow) {
+                    await this._updateLastShownDate();
+                    this._showSentimentPrompt('ai_interaction');
+                }
+            }, RATING_DELAY_MS);
+            return;
+        }
+
+        const userSaidYes = await Storage.getData(STORAGE_KEYS.USER_SENTIMENT_POSITIVE);
+
+        if (userSaidYes === 'true') {
+            setTimeout(async () => {
+                const canShow    = await this._checkBasicEligibility();
+                const shownToday = await this._wasShownToday();
+                if (canShow && !shownToday && !this._isShowingPrompt) {
+                    await this._updateLastShownDate();
+                    this._trackEvent('rate_prompt_shown', { source: 'ai_interaction', type: 'direct_rating' });
+                    await this.triggerNativeRating();
+                }
+            }, RATING_DELAY_MS);
+        } else {
+            setTimeout(async () => {
+                const canShow    = await this._checkBasicEligibility();
+                const shownToday = await this._wasShownToday();
+                if (canShow && !shownToday && !this._isShowingPrompt) {
+                    await this._updateLastShownDate();
+                    this._showSentimentPrompt('ai_interaction');
                 }
-            } else {
-                console.log("Rating requestReviewIfNeeded not needed");
-                return {
-                    success: false,
-                    shown: false,
-                    tooSoon: true,
-                    message: 'Review request too soon (less than 7 days since last request)'
-                };
+            }, RATING_DELAY_MS);
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // onCreditsRunningLow
+    // Called after a successful action when credits are low.
+    // @param currentCredits — current credit count
+    // -----------------------------------------------------------------------
+    onCreditsRunningLow = async (currentCredits) => {
+        if (this._isShowingPrompt) return;
+        if (currentCredits > LOW_CREDITS_THRESHOLD) return;
+
+        const canShow = await this._checkBasicEligibility();
+        if (!canShow) return;
+
+        const shownToday = await this._wasShownToday();
+        if (shownToday) return;
+
+        const userSaidYes = await Storage.getData(STORAGE_KEYS.USER_SENTIMENT_POSITIVE);
+        if (userSaidYes === 'true') {
+            await this._updateLastShownDate();
+            this._trackEvent('rate_prompt_shown', { source: 'credits_low', type: 'direct_rating' });
+            await this.triggerNativeRating();
+        } else {
+            const alreadyShown = await Storage.getData(STORAGE_KEYS.LOW_CREDITS_PROMPT_SHOWN);
+            if (alreadyShown === 'true') return;
+            await Storage.storeData(STORAGE_KEYS.LOW_CREDITS_PROMPT_SHOWN, 'true');
+            await this._updateLastShownDate();
+            this._showSentimentPrompt('credits_low');
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // onResultDownloadedOrShared
+    // Called when the user downloads or shares an AI result.
+    // @param actionType — 'download' | 'share'
+    // -----------------------------------------------------------------------
+    onResultDownloadedOrShared = async (actionType) => {
+        if (this._isShowingPrompt) return;
+
+        const canShow = await this._checkBasicEligibility();
+        if (!canShow) return;
+
+        const shownToday = await this._wasShownToday();
+        if (shownToday) return;
+
+        const userSaidYes = await Storage.getData(STORAGE_KEYS.USER_SENTIMENT_POSITIVE);
+        if (userSaidYes === 'true') {
+            await this._updateLastShownDate();
+            this._trackEvent('rate_prompt_shown', { source: `result_${actionType}`, type: 'direct_rating' });
+            await this.triggerNativeRating();
+        } else {
+            const alreadyShown = await Storage.getData(STORAGE_KEYS.DOWNLOAD_SHARE_PROMPT_SHOWN);
+            if (alreadyShown === 'true') return;
+            await Storage.storeData(STORAGE_KEYS.DOWNLOAD_SHARE_PROMPT_SHOWN, 'true');
+            await this._updateLastShownDate();
+            this._showSentimentPrompt(`result_${actionType}`);
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // triggerNativeRating — calls StoreReview.requestReview()
+    // -----------------------------------------------------------------------
+    triggerNativeRating = async () => {
+        this._trackEvent('native_rating_prompt_called', { platform: Platform.OS });
+        try {
+            const attemptsStr = await Storage.getData(STORAGE_KEYS.RATING_ATTEMPTS_COUNT);
+            const newAttempts = (attemptsStr ? parseInt(attemptsStr, 10) : 0) + 1;
+            await Storage.storeData(STORAGE_KEYS.RATING_ATTEMPTS_COUNT, String(newAttempts));
+            await StoreReview.requestReview();
+        } catch (error) {
+            console.error('[RatingFlow] Rating request failed:', error);
+            this._trackEvent('native_rating_api_error', { platform: Platform.OS, error: String(error) });
+        } finally {
+            this._isShowingPrompt = false;
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // onUserRespondedYes — call from the sentiment prompt YES handler
+    // -----------------------------------------------------------------------
+    onUserRespondedYes = async () => {
+        this._trackEvent('rate_prompt_response', { response: 'yes' });
+        await Storage.storeData(STORAGE_KEYS.USER_SENTIMENT_POSITIVE, 'true');
+        await this.triggerNativeRating();
+    }
+
+    // -----------------------------------------------------------------------
+    // onUserRespondedNo — call from the sentiment prompt NO handler
+    // -----------------------------------------------------------------------
+    onUserRespondedNo = () => {
+        this._trackEvent('rate_prompt_response', { response: 'no' });
+        this._showFeedbackForm();
+    }
+
+    // -----------------------------------------------------------------------
+    // submitFeedback — call when the user submits written feedback
+    // @param feedbackText — the feedback string
+    // -----------------------------------------------------------------------
+    submitFeedback = async (feedbackText) => {
+        try {
+            this._trackEvent('feedback_submitted', { feedback_text: feedbackText });
+            await Storage.storeData(STORAGE_KEYS.FEEDBACK_SUBMITTED, 'true');
+            if (this._onSubmitFeedback) await this._onSubmitFeedback(feedbackText);
+        } catch (error) {
+            console.error('[RatingFlow] Failed to submit feedback:', error);
+            throw error;
+        } finally {
+            this._isShowingPrompt = false;
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // onFeedbackCanceled — call when the user dismisses the feedback form
+    // -----------------------------------------------------------------------
+    onFeedbackCanceled = () => {
+        this._trackEvent('feedback_canceled');
+        this._isShowingPrompt = false;
+    }
+
+    // -----------------------------------------------------------------------
+    // reset — clears all persisted rating state (for debugging/testing)
+    // -----------------------------------------------------------------------
+    reset = async () => {
+        await Promise.all(Object.values(STORAGE_KEYS).map(key => Storage.removeData(key)));
+        this._hasCompletedFirstInteraction = false;
+        this._isShowingPrompt = false;
+    }
+
+    // -----------------------------------------------------------------------
+    // Legacy: showRatingDialog — kept for backwards compatibility
+    // -----------------------------------------------------------------------
+    showRatingDialog = async (force = false) => {
+        try {
+            if (force) {
+                await this.triggerNativeRating();
+                return { success: true, shown: true };
             }
+            const canShow = await this._checkBasicEligibility();
+            if (!canShow) return { success: false, shown: false, tooSoon: true };
+            await this.triggerNativeRating();
+            return { success: true, shown: true };
+        } catch (error) {
+            console.error('[RatingFlow] showRatingDialog error:', error);
+            return { success: false, shown: false, error: true, message: error.message };
+        }
+    }
+
+    // =======================================================================
+    // Private helpers
+    // =======================================================================
+
+    _checkBasicEligibility = async () => {
+        try {
+            const isAvailable = await StoreReview.isAvailableAsync();
+            if (!isAvailable) return false;
+
+            const feedbackSubmitted = await Storage.getData(STORAGE_KEYS.FEEDBACK_SUBMITTED);
+            if (feedbackSubmitted === 'true') return false;
+
+            const attemptsStr = await Storage.getData(STORAGE_KEYS.RATING_ATTEMPTS_COUNT);
+            const attempts = attemptsStr ? parseInt(attemptsStr, 10) : 0;
+            if (attempts >= MAX_RATING_ATTEMPTS) return false;
+
+            return true;
         } catch (error) {
-            console.log("Error en requestReview", error);
-            return {
-                success: false,
-                shown: false,
-                error: true,
-                message: error.message
-            };
+            console.error('[RatingFlow] Error checking basic eligibility:', error);
+            return false;
         }
     }
 
-    requestReviewIfNeeded = async () => {
-        const lastReviewRequestString = await Storage.getData('lastReviewRequest');
-        const lastReviewRequest = lastReviewRequestString ? Number(lastReviewRequestString) : 0;
-        const now = Date.now();
-        if (now - lastReviewRequest > REVIEW_INTERVAL) {
-            const available = await StoreReview.isAvailableAsync();
-            if (available) {
-                await StoreReview.requestReview();
-                await Storage.storeData('lastReviewRequest', now.toString());
+    _wasShownToday = async () => {
+        try {
+            const lastShownDate = await Storage.getData(STORAGE_KEYS.LAST_RATING_PROMPT_DATE);
+            if (lastShownDate) {
+                const lastDate = new Date(lastShownDate);
+                const now = new Date();
+                return lastDate.toDateString() === now.toDateString();
             }
+            return false;
+        } catch (error) {
+            console.error('[RatingFlow] Error checking last shown date:', error);
+            return false;
+        }
+    }
+
+    _updateLastShownDate = async () => {
+        await Storage.storeData(STORAGE_KEYS.LAST_RATING_PROMPT_DATE, new Date().toISOString());
+    }
+
+    _showSentimentPrompt = (source) => {
+        this._isShowingPrompt = true;
+        this._trackEvent('rate_prompt_shown', { source: source || 'ai_interaction' });
+        if (this._onShowSentimentPrompt) {
+            this._onShowSentimentPrompt(source);
+        } else {
+            console.warn('[RatingFlow] No sentiment prompt handler configured. Call AppsSDK.rating.configure().');
+        }
+    }
+
+    _showFeedbackForm = () => {
+        this._trackEvent('feedback_screen_shown');
+        if (this._onShowFeedbackForm) {
+            this._onShowFeedbackForm();
+        } else {
+            console.warn('[RatingFlow] No feedback form handler configured. Call AppsSDK.rating.configure().');
+        }
+    }
+
+    _trackEvent = (eventName, properties = {}) => {
+        if (this._onTrackEvent) {
+            this._onTrackEvent(eventName, { ...properties, timestamp: new Date().toISOString() });
         }
     }
 }

package/src/libraries/index.js

@@ -14,3 +14,4 @@ export { default as HomeActions }           from './QuickActions';
 export { default as Facebook }              from './Facebook';
 export { default as Firebase }              from './Firebase';
 export { default as Legal }                 from './Legal';
+export { default as Authentication }        from './Authentication';