Android Open Source - Robook Facebook Time Spent Data

From Project

Back to project page Robook.
License

The source code is released under:
MIT License
If you think the Android project Robook listed in this page is inappropriate, such as containing malicious code/tools or violating the copyright, please email info at java2s dot com, thanks.
Java Source Code

package com.facebook;
//  www .  ja  va  2s.  c o m
import android.os.Bundle;
import android.text.format.DateUtils;

import com.facebook.internal.Logger;

import java.io.Serializable;

class FacebookTimeSpentData implements Serializable {
    // Constants
    private static final long serialVersionUID = 1L;
    private static final String TAG = AppEventsLogger.class.getCanonicalName();
    private static final long FIRST_TIME_LOAD_RESUME_TIME = -1;
    private static final long INTERRUPTION_THRESHOLD_MILLISECONDS = 1000;
    private static final long NUM_MILLISECONDS_IDLE_TO_BE_NEW_SESSION =
            60 * DateUtils.SECOND_IN_MILLIS;
    private static final long APP_ACTIVATE_SUPPRESSION_PERIOD_IN_MILLISECONDS =
            5 * DateUtils.MINUTE_IN_MILLIS;

    // Should be kept in sync with the iOS sdk
    private static final long[] INACTIVE_SECONDS_QUANTA =
        new long[] {
            5 * DateUtils.MINUTE_IN_MILLIS,
            15 * DateUtils.MINUTE_IN_MILLIS,
            30 * DateUtils.MINUTE_IN_MILLIS,
            1 * DateUtils.HOUR_IN_MILLIS,
            6 * DateUtils.HOUR_IN_MILLIS,
            12 * DateUtils.HOUR_IN_MILLIS,
            1 * DateUtils.DAY_IN_MILLIS,
            2 * DateUtils.DAY_IN_MILLIS,
            3 * DateUtils.DAY_IN_MILLIS,
            7 * DateUtils.DAY_IN_MILLIS,
            14 * DateUtils.DAY_IN_MILLIS,
            21 * DateUtils.DAY_IN_MILLIS,
            28 * DateUtils.DAY_IN_MILLIS,
            60 * DateUtils.DAY_IN_MILLIS,
            90 * DateUtils.DAY_IN_MILLIS,
            120 * DateUtils.DAY_IN_MILLIS,
            150 * DateUtils.DAY_IN_MILLIS,
            180 * DateUtils.DAY_IN_MILLIS,
            365 * DateUtils.DAY_IN_MILLIS,
        };

    private boolean isWarmLaunch;
    private boolean isAppActive;
    private long lastActivateEventLoggedTime;

    // Member data that's persisted to disk
    private long lastResumeTime;
    private long lastSuspendTime;
    private long millisecondsSpentInSession;
    private int interruptionCount;

    /**
     * Serialization proxy for the FacebookTimeSpentData class. This is version 1 of
     * serialization. Future serializations may differ in format. This
     * class should not be modified. If serializations formats change,
     * create a new class SerializationProxyVx.
     */
    private static class SerializationProxyV1 implements Serializable {
        private static final long serialVersionUID = 6L;

        private final long lastResumeTime;
        private final long lastSuspendTime;
        private final long millisecondsSpentInSession;
        private final int interruptionCount;

        SerializationProxyV1(
            long lastResumeTime,
            long lastSuspendTime,
            long millisecondsSpentInSession,
            int interruptionCount
        ) {
            this.lastResumeTime = lastResumeTime;
            this.lastSuspendTime = lastSuspendTime;
            this.millisecondsSpentInSession = millisecondsSpentInSession;
            this.interruptionCount = interruptionCount;
        }

        private Object readResolve() {
            return new FacebookTimeSpentData(
                lastResumeTime,
                lastSuspendTime,
                millisecondsSpentInSession,
                interruptionCount);
        }
    }

    FacebookTimeSpentData() {
        resetSession();
    }

    /**
     * Constructor to be used for V1 serialization only, DO NOT CHANGE.
     */
    private FacebookTimeSpentData(
        long lastResumeTime,
        long lastSuspendTime,
        long millisecondsSpentInSession,
        int interruptionCount
    ) {
        resetSession();
        this.lastResumeTime = lastResumeTime;
        this.lastSuspendTime = lastSuspendTime;
        this.millisecondsSpentInSession = millisecondsSpentInSession;
        this.interruptionCount = interruptionCount;
    }

    private Object writeReplace() {
        return new SerializationProxyV1(
            lastResumeTime,
            lastSuspendTime,
            millisecondsSpentInSession,
            interruptionCount
        );
    }

    void onSuspend(AppEventsLogger logger, long eventTime) {
        if (!isAppActive) {
            Logger.log(LoggingBehavior.APP_EVENTS, TAG, "Suspend for inactive app");
            return;
        }

        long now = eventTime;
        long delta = (now - lastResumeTime);
        if (delta < 0) {
            Logger.log(LoggingBehavior.APP_EVENTS, TAG, "Clock skew detected");
            delta = 0;
        }
        millisecondsSpentInSession += delta;
        lastSuspendTime = now;
        isAppActive = false;
    }

    void onResume(AppEventsLogger logger, long eventTime) {
        long now = eventTime;

        // Retain old behavior for activated app event - log the event if the event hasn't
        // been logged in the previous suppression interval or this is a cold launch.
        // If this is a cold launch, always log the event. Otherwise, use the last
        // event log time to determine if the app activate should be suppressed or not.
        if (isColdLaunch() ||
            ((now - lastActivateEventLoggedTime) > APP_ACTIVATE_SUPPRESSION_PERIOD_IN_MILLISECONDS)) {
            logger.logEvent(AppEventsConstants.EVENT_NAME_ACTIVATED_APP);
            lastActivateEventLoggedTime = now;
        }

        // If this is an application that's not calling onSuspend yet, log and return. We can't
        // track time spent for this application as there are no calls to onSuspend.
        if (isAppActive) {
          Logger.log(LoggingBehavior.APP_EVENTS, TAG, "Resume for active app");
          return;
        }

        long interruptionDurationMillis = wasSuspendedEver() ? now - lastSuspendTime : 0;
        if (interruptionDurationMillis < 0) {
          Logger.log(LoggingBehavior.APP_EVENTS, TAG, "Clock skew detected");
          interruptionDurationMillis = 0;
        }

        // If interruption duration is > new session threshold, then log old session
        // event and start a new session.
        if (interruptionDurationMillis > NUM_MILLISECONDS_IDLE_TO_BE_NEW_SESSION) {
            logAppDeactivatedEvent(logger, interruptionDurationMillis);
        } else {
            // We're not logging this resume event - check to see if this should count
            // as an interruption
            if (interruptionDurationMillis > INTERRUPTION_THRESHOLD_MILLISECONDS) {
                interruptionCount++;
            }
        }

        lastResumeTime = now;
        isAppActive = true;
    }

    private void logAppDeactivatedEvent(AppEventsLogger logger, long interruptionDurationMillis) {
        // Log the old session information and clear the data
        Bundle eventParams = new Bundle();
        eventParams.putInt(
                AppEventsConstants.EVENT_NAME_SESSION_INTERRUPTIONS,
                interruptionCount);
        eventParams.putInt(
                AppEventsConstants.EVENT_NAME_TIME_BETWEEN_SESSIONS,
                getQuantaIndex(interruptionDurationMillis));
        logger.logEvent(
                AppEventsConstants.EVENT_NAME_DEACTIVATED_APP,
                (millisecondsSpentInSession/DateUtils.SECOND_IN_MILLIS),
                eventParams);
        resetSession();
    }

    private static int getQuantaIndex(long timeBetweenSessions) {
        int quantaIndex = 0;

        while (
            quantaIndex < INACTIVE_SECONDS_QUANTA.length &&
            INACTIVE_SECONDS_QUANTA[quantaIndex] < timeBetweenSessions
        ) {
            ++quantaIndex;
        }

        return quantaIndex;
    }

    private void resetSession() {
        isAppActive = false;
        lastResumeTime = FIRST_TIME_LOAD_RESUME_TIME;
        lastSuspendTime = FIRST_TIME_LOAD_RESUME_TIME;
        interruptionCount = 0;
        millisecondsSpentInSession = 0;
    }

    private boolean wasSuspendedEver() {
        return lastSuspendTime != FIRST_TIME_LOAD_RESUME_TIME;
    }

    private boolean isColdLaunch() {
        // On the very first call in the process lifecycle, this will always
        // return true. After that, it will always return false.
        boolean result = !isWarmLaunch;
        isWarmLaunch = true;
        return result;
    }
}
Java Source Code List
