Subversion Repositories SmartDukaan

/**

 * Copyright 2010-present Facebook.

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *    http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package com.facebook;

import android.content.ContentResolver;

import android.content.Context;

import android.content.SharedPreferences;

import android.content.pm.ApplicationInfo;

import android.content.pm.PackageInfo;

import android.content.pm.PackageManager;

import android.content.pm.Signature;

import android.database.Cursor;

import android.net.Uri;

import android.os.AsyncTask;

import android.os.Handler;

import android.os.Looper;

import android.util.Base64;

import android.util.Log;

import com.facebook.android.BuildConfig;

import com.facebook.internal.AttributionIdentifiers;

import com.facebook.internal.Utility;

import com.facebook.internal.Validate;

import com.facebook.model.GraphObject;

import org.json.JSONException;

import org.json.JSONObject;

import java.lang.reflect.Field;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

import java.util.Arrays;

import java.util.Collections;

import java.util.HashSet;

import java.util.Set;

import java.util.concurrent.*;

import java.util.concurrent.atomic.AtomicInteger;

import java.util.concurrent.atomic.AtomicLong;

/**

 * Allows some customization of sdk behavior.

 */

public final class Settings {

    private static final String TAG = Settings.class.getCanonicalName();

    private static final HashSet<LoggingBehavior> loggingBehaviors =

            new HashSet<LoggingBehavior>(Arrays.asList(LoggingBehavior.DEVELOPER_ERRORS));

    private static volatile Executor executor;

    private static volatile boolean shouldAutoPublishInstall;

    private static volatile String appVersion;

    private static volatile String applicationId;

    private static volatile String appClientToken;

    private static volatile boolean defaultsLoaded = false;

    private static final String FACEBOOK_COM = "facebook.com";

    private static volatile String facebookDomain = FACEBOOK_COM;

    private static AtomicLong onProgressThreshold = new AtomicLong(65536);

    private static volatile boolean platformCompatibilityEnabled;

    private static volatile boolean isDebugEnabled = BuildConfig.DEBUG;

    private static final int DEFAULT_CORE_POOL_SIZE = 5;

    private static final int DEFAULT_MAXIMUM_POOL_SIZE = 128;

    private static final int DEFAULT_KEEP_ALIVE = 1;

    private static final Object LOCK = new Object();

    private static final Uri ATTRIBUTION_ID_CONTENT_URI =

            Uri.parse("content://com.facebook.katana.provider.AttributionIdProvider");

    private static final String ATTRIBUTION_ID_COLUMN_NAME = "aid";

    private static final String ATTRIBUTION_PREFERENCES = "com.facebook.sdk.attributionTracking";

    private static final String PUBLISH_ACTIVITY_PATH = "%s/activities";

    private static final String MOBILE_INSTALL_EVENT = "MOBILE_APP_INSTALL";

    private static final String ANALYTICS_EVENT = "event";

    private static final String AUTO_PUBLISH = "auto_publish";

    private static final String APP_EVENT_PREFERENCES = "com.facebook.sdk.appEventPreferences";

    private static final BlockingQueue<Runnable> DEFAULT_WORK_QUEUE = new LinkedBlockingQueue<Runnable>(10);

    private static final ThreadFactory DEFAULT_THREAD_FACTORY = new ThreadFactory() {

        private final AtomicInteger counter = new AtomicInteger(0);

        public Thread newThread(Runnable runnable) {

            return new Thread(runnable, "FacebookSdk #" + counter.incrementAndGet());

        }

    };

    /**

     * loadDefaultsFromMetadata will attempt to load certain settings (e.g., application ID, client token) from

     * metadata in the app's AndroidManifest.xml. The application ID will be read from this key.

     */

    public static final String APPLICATION_ID_PROPERTY = "com.facebook.sdk.ApplicationId";

    /**

     * loadDefaultsFromMetadata will attempt to load certain settings (e.g., application ID, client token) from

     * metadata in the app's AndroidManifest.xml. The client token will be read from this key.

     */

    public static final String CLIENT_TOKEN_PROPERTY = "com.facebook.sdk.ClientToken";

    private static Boolean sdkInitialized = false;

    /**

     * Initialize SDK

     * This function will be called once in the application, it is tried to be called as early as possible;

     * This is the place to register broadcast listeners.

     */

    public static synchronized void sdkInitialize(Context context) {

        if (sdkInitialized == true) {

          return;

        }

        // Make sure we've loaded default settings if we haven't already.

        Settings.loadDefaultsFromMetadataIfNeeded(context);

        // Load app settings from network so that dialog configs are available

        Utility.loadAppSettingsAsync(context, Settings.getApplicationId());

        BoltsMeasurementEventListener.getInstance(context.getApplicationContext());

        sdkInitialized = true;

    }

    /**

     * Certain logging behaviors are available for debugging beyond those that should be

     * enabled in production.

     *

     * Returns the types of extended logging that are currently enabled.

     *

     * @return a set containing enabled logging behaviors

     */

    public static final Set<LoggingBehavior> getLoggingBehaviors() {

        synchronized (loggingBehaviors) {

            return Collections.unmodifiableSet(new HashSet<LoggingBehavior>(loggingBehaviors));

        }

    }

    /**

     * Certain logging behaviors are available for debugging beyond those that should be

     * enabled in production.

     *

     * Enables a particular extended logging in the sdk.

     *

     * @param behavior

     *          The LoggingBehavior to enable

     */

    public static final void addLoggingBehavior(LoggingBehavior behavior) {

        synchronized (loggingBehaviors) {

            loggingBehaviors.add(behavior);

        }

    }

    /**

     * Certain logging behaviors are available for debugging beyond those that should be

     * enabled in production.

     *

     * Disables a particular extended logging behavior in the sdk.

     *

     * @param behavior

     *          The LoggingBehavior to disable

     */

    public static final void removeLoggingBehavior(LoggingBehavior behavior) {

        synchronized (loggingBehaviors) {

            loggingBehaviors.remove(behavior);

        }

    }

    /**

     * Certain logging behaviors are available for debugging beyond those that should be

     * enabled in production.

     *

     * Disables all extended logging behaviors.

     */

    public static final void clearLoggingBehaviors() {

        synchronized (loggingBehaviors) {

            loggingBehaviors.clear();

        }

    }

    /**

     * Certain logging behaviors are available for debugging beyond those that should be

     * enabled in production.

     *

     * Checks if a particular extended logging behavior is enabled.

     *

     * @param behavior

     *          The LoggingBehavior to check

     * @return whether behavior is enabled

     */

    public static final boolean isLoggingBehaviorEnabled(LoggingBehavior behavior) {

        synchronized (loggingBehaviors) {

            return Settings.isDebugEnabled() && loggingBehaviors.contains(behavior);

        }

    }

    /**

     * This method is deprecated.  Use {@link Settings#isDebugEnabled()} instead.

     */

    @Deprecated

    public static final boolean isLoggingEnabled() {

        return isDebugEnabled();

    }

    /**

     * This method is deprecated.  Use {@link Settings#setIsDebugEnabled(boolean)} instead.

     */

    @Deprecated

    public static final void setIsLoggingEnabled(boolean enabled) {

        setIsDebugEnabled(enabled);

    }

    /**

     * Indicates if we are in debug mode.

     */

    public static final boolean isDebugEnabled() {

        return isDebugEnabled;

    }

    /**

     * Used to enable or disable logging, and other debug features. Defaults to BuildConfig.DEBUG.

     * @param enabled Debug features (like logging) are enabled if true, disabled if false.

     */

    public static final void setIsDebugEnabled(boolean enabled) {

        isDebugEnabled = enabled;

    }

    /**

     * Returns the Executor used by the SDK for non-AsyncTask background work.

     *

     * By default this uses AsyncTask Executor via reflection if the API level is high enough.

     * Otherwise this creates a new Executor with defaults similar to those used in AsyncTask.

     *

     * @return an Executor used by the SDK.  This will never be null.

     */

    public static Executor getExecutor() {

        synchronized (LOCK) {

            if (Settings.executor == null) {

                Executor executor = getAsyncTaskExecutor();

                if (executor == null) {

                    executor = new ThreadPoolExecutor(DEFAULT_CORE_POOL_SIZE, DEFAULT_MAXIMUM_POOL_SIZE,

                            DEFAULT_KEEP_ALIVE, TimeUnit.SECONDS, DEFAULT_WORK_QUEUE, DEFAULT_THREAD_FACTORY);

                }

                Settings.executor = executor;

            }

        }

        return Settings.executor;

    }

    /**

     * Sets the Executor used by the SDK for non-AsyncTask background work.

     *

     * @param executor

     *          the Executor to use; must not be null.

     */

    public static void setExecutor(Executor executor) {

        Validate.notNull(executor, "executor");

        synchronized (LOCK) {

            Settings.executor = executor;

        }

    }

    /**

     * Gets the base Facebook domain to use when making Web requests; in production code this will always be

     * "facebook.com".

     *

     * @return the Facebook domain

     */

    public static String getFacebookDomain() {

        return facebookDomain;

    }

    /**

     * Sets the base Facebook domain to use when making Web requests. This defaults to "facebook.com", but may

     * be overridden to, e.g., "beta.facebook.com" to direct requests at a different domain. This method should

     * never be called from production code.

     *

     * @param facebookDomain the base domain to use instead of "facebook.com"

     */

    public static void setFacebookDomain(String facebookDomain) {

        if (!BuildConfig.DEBUG) {

            Log.w(TAG, "WARNING: Calling setFacebookDomain from non-DEBUG code.");

        }

        Settings.facebookDomain = facebookDomain;

    }

    private static Executor getAsyncTaskExecutor() {

        Field executorField = null;

        try {

            executorField = AsyncTask.class.getField("THREAD_POOL_EXECUTOR");

        } catch (NoSuchFieldException e) {

            return null;

        }

        Object executorObject = null;

        try {

            executorObject = executorField.get(null);

        } catch (IllegalAccessException e) {

            return null;

        }

        if (executorObject == null) {

            return null;

        }

        if (!(executorObject instanceof Executor)) {

            return null;

        }

        return (Executor) executorObject;

    }

    static void publishInstallAsync(final Context context, final String applicationId,

        final Request.Callback callback) {

        // grab the application context ahead of time, since we will return to the caller immediately.

        final Context applicationContext = context.getApplicationContext();

        Settings.getExecutor().execute(new Runnable() {

            @Override

            public void run() {

                final Response response = Settings.publishInstallAndWaitForResponse(applicationContext, applicationId, false);

                if (callback != null) {

                    // invoke the callback on the main thread.

                    Handler handler = new Handler(Looper.getMainLooper());

                    handler.post(new Runnable() {

                        @Override

                        public void run() {

                            callback.onCompleted(response);

                        }

                    });

                }

            }

        });

    }

    /**

     * Sets whether opening a Session should automatically publish install attribution to the Facebook graph.

     *

     * @param shouldAutoPublishInstall true to automatically publish, false to not

     *

     * This method is deprecated.  See {@link AppEventsLogger#activateApp(Context, String)} for more info.

     */

    @Deprecated

    public static void setShouldAutoPublishInstall(boolean shouldAutoPublishInstall) {

        Settings.shouldAutoPublishInstall = shouldAutoPublishInstall;

    }

    /**

     * Gets whether opening a Session should automatically publish install attribution to the Facebook graph.

     *

     * @return true to automatically publish, false to not

     *

     * This method is deprecated.  See {@link AppEventsLogger#activateApp(Context, String)} for more info.

     */

    @Deprecated

    public static boolean getShouldAutoPublishInstall() {

        return shouldAutoPublishInstall;

    }

    static Response publishInstallAndWaitForResponse(

            final Context context,

            final String applicationId,

            final boolean isAutoPublish) {

        try {

            if (context == null || applicationId == null) {

                throw new IllegalArgumentException("Both context and applicationId must be non-null");

            }

            AttributionIdentifiers identifiers = AttributionIdentifiers.getAttributionIdentifiers(context);

            SharedPreferences preferences = context.getSharedPreferences(ATTRIBUTION_PREFERENCES, Context.MODE_PRIVATE);

            String pingKey = applicationId+"ping";

            String jsonKey = applicationId+"json";

            long lastPing = preferences.getLong(pingKey, 0);

            String lastResponseJSON = preferences.getString(jsonKey, null);

            // prevent auto publish from occurring if we have an explicit call.

            if (!isAutoPublish) {

                setShouldAutoPublishInstall(false);

            }

            GraphObject publishParams = GraphObject.Factory.create();

            publishParams.setProperty(ANALYTICS_EVENT, MOBILE_INSTALL_EVENT);

            Utility.setAppEventAttributionParameters(publishParams,

                    identifiers,

                    Utility.getHashedDeviceAndAppID(context, applicationId),

                    getLimitEventAndDataUsage(context));

            publishParams.setProperty(AUTO_PUBLISH, isAutoPublish);

            publishParams.setProperty("application_package_name", context.getPackageName());

            String publishUrl = String.format(PUBLISH_ACTIVITY_PATH, applicationId);

            Request publishRequest = Request.newPostRequest(null, publishUrl, publishParams, null);

            if (lastPing != 0) {

                GraphObject graphObject = null;

                try {

                    if (lastResponseJSON != null) {

                        graphObject = GraphObject.Factory.create(new JSONObject(lastResponseJSON));

                    }

                }

                catch (JSONException je) {

                    // return the default graph object if there is any problem reading the data.

                }

                if (graphObject == null) {

                    return Response.createResponsesFromString("true", null, new RequestBatch(publishRequest), true).get(0);

                } else {

                    return new Response(null, null, null, graphObject, true);

                }

            } else if (identifiers == null ||

                       (identifiers.getAndroidAdvertiserId() == null && identifiers.getAttributionId() == null)) {

                throw new FacebookException("No attribution id available to send to server.");

            } else {

                if (!Utility.queryAppSettings(applicationId, false).supportsAttribution()) {

                    throw new FacebookException("Install attribution has been disabled on the server.");

                }

                Response publishResponse = publishRequest.executeAndWait();

                // denote success since no error threw from the post.

                SharedPreferences.Editor editor = preferences.edit();

                lastPing = System.currentTimeMillis();

                editor.putLong(pingKey, lastPing);

                // if we got an object response back, cache the string of the JSON.

                if (publishResponse.getGraphObject() != null &&

                    publishResponse.getGraphObject().getInnerJSONObject() != null) {

                    editor.putString(jsonKey, publishResponse.getGraphObject().getInnerJSONObject().toString());

                }

                editor.apply();

                return publishResponse;

            }

        } catch (Exception e) {

            // if there was an error, fall through to the failure case.

            Utility.logd("Facebook-publish", e);

            return new Response(null, null, new FacebookRequestError(null, e));

        }

    }

    /**

     * Acquire the current attribution id from the facebook app.

     * @return returns null if the facebook app is not present on the phone.

     */

    public static String getAttributionId(ContentResolver contentResolver) {

        Cursor c = null;

        try {

            String [] projection = {ATTRIBUTION_ID_COLUMN_NAME};

            c = contentResolver.query(ATTRIBUTION_ID_CONTENT_URI, projection, null, null, null);

            if (c == null || !c.moveToFirst()) {

                return null;

            }

            String attributionId = c.getString(c.getColumnIndex(ATTRIBUTION_ID_COLUMN_NAME));

            return attributionId;

        } catch (Exception e) {

            Log.d(TAG, "Caught unexpected exception in getAttributionId(): " + e.toString());

            return null;

        } finally {

            if (c != null) {

                c.close();

            }

        }

    }

    /**

     * Gets the application version to the provided string.

     * @return application version set via setAppVersion.

     */

    public static String getAppVersion() {

        return appVersion;

    }

    /**

     * Sets the application version to the provided string.  AppEventsLogger.logEvent calls logs its event with the

     * current app version, and App Insights allows breakdown of events by app version.

     *

     * @param appVersion  The version identifier of the Android app that events are being logged through.

     *                    Enables analysis and breakdown of logged events by app version.

     */

    public static void setAppVersion(String appVersion) {

        Settings.appVersion = appVersion;

    }

    /**

     * Gets the current version of the Facebook SDK for Android as a string.

     *

     * @return the current version of the SDK

     */

    public static String getSdkVersion() {

        return FacebookSdkVersion.BUILD;

    }

    /**

     * Gets whether data such as that generated through AppEventsLogger and sent to Facebook should be restricted from

     * being used for purposes other than analytics and conversions, such as for targeting ads to this user.  Defaults

     * to false.  This value is stored on the device and persists across app launches.

     *

     * @param context   Used to read the value.

     */

    public static boolean getLimitEventAndDataUsage(Context context) {

        SharedPreferences preferences = context.getSharedPreferences(APP_EVENT_PREFERENCES, Context.MODE_PRIVATE);

        return preferences.getBoolean("limitEventUsage", false);

    }

    /**

     * Sets whether data such as that generated through AppEventsLogger and sent to Facebook should be restricted from

     * being used for purposes other than analytics and conversions, such as for targeting ads to this user.  Defaults

     * to false.  This value is stored on the device and persists across app launches.  Changes to this setting will

     * apply to app events currently queued to be flushed.

     *

     * @param context   Used to persist this value across app runs.

     */

    public static void setLimitEventAndDataUsage(Context context, boolean limitEventUsage) {

        context.getSharedPreferences(APP_EVENT_PREFERENCES, Context.MODE_PRIVATE)

            .edit()

            .putBoolean("limitEventUsage", limitEventUsage)

            .apply();

    }

    /**

     * Gets the threshold used to report progress on requests.

     */

    public static long getOnProgressThreshold() {

        return onProgressThreshold.get();

    }

    /**

     * Sets the threshold used to report progress on requests. Note that the value will be read when the

     * request is started and can not be changed during a request (or batch) execution.

     *

     * @param threshold The number of bytes progressed to force a callback.

     */

    public static void setOnProgressThreshold(long threshold) {

        onProgressThreshold.set(threshold);

    }

    /**

     * Gets whether the SDK is running in Platform Compatibility mode (i.e. making calls to v1.0 endpoints by default)

     * The default is false.

     *

     * @return the value

     */

    public static boolean getPlatformCompatibilityEnabled() {

        return platformCompatibilityEnabled;

    }

    /**

     * Sets whether the SDK is running in Platform Compatibility mode (i.e. making calls to v1.0 endpoints by default)

     * The default is false.  This is provided for apps that have strong reason not to take advantage of new

     * capabilities in version 2.0+ of the API.

     *

     * @param platformCompatibilityEnabled whether to set Legacy Graph API mode

     */

    public static void setPlatformCompatibilityEnabled(boolean platformCompatibilityEnabled) {

        Settings.platformCompatibilityEnabled = platformCompatibilityEnabled;

    }

    /**

     * Loads default values for certain settings from an application's AndroidManifest.xml metadata, if possible.

     * If values have been explicitly set for a particular setting, they will not be overwritten. The following

     * settings are currently loaded from metadata: APPLICATION_ID_PROPERTY, CLIENT_TOKEN_PROPERTY

     * @param context the Context to use for loading metadata

     */

    public static void loadDefaultsFromMetadata(Context context) {

        defaultsLoaded = true;

        if (context == null) {

            return;

        }

        ApplicationInfo ai = null;

        try {

            ai = context.getPackageManager().getApplicationInfo(

                    context.getPackageName(), PackageManager.GET_META_DATA);

        } catch (PackageManager.NameNotFoundException e) {

            return;

        }

        if (ai == null || ai.metaData == null) {

            return;

        }

        if (applicationId == null) {

            applicationId = ai.metaData.getString(APPLICATION_ID_PROPERTY);

        }

        if (appClientToken == null) {

            appClientToken = ai.metaData.getString(CLIENT_TOKEN_PROPERTY);

        }

    }

    static void loadDefaultsFromMetadataIfNeeded(Context context) {

        if (!defaultsLoaded) {

            loadDefaultsFromMetadata(context);

        }

    }

    public static String getApplicationSignature(Context context) {

        if (context == null) {

            return null;

        }

        PackageManager packageManager = context.getPackageManager();

        if (packageManager == null) {

            return null;

        }

        String packageName = context.getPackageName();

        PackageInfo pInfo;

        try {

            pInfo = packageManager.getPackageInfo(packageName, PackageManager.GET_SIGNATURES);

        } catch (PackageManager.NameNotFoundException e) {

            return null;

        }

        Signature[] signatures = pInfo.signatures;

        if (signatures == null || signatures.length == 0) {

            return null;

        }

        MessageDigest md;

        try {

            md = MessageDigest.getInstance("SHA-1");

        } catch (NoSuchAlgorithmException e) {

            return null;

        }

        md.update(pInfo.signatures[0].toByteArray());

        return Base64.encodeToString(md.digest(),  Base64.URL_SAFE | Base64.NO_PADDING);

    }

    /**

     * Gets the Facebook application ID for the current app. This will be null unless explicitly set or unless

     * loadDefaultsFromMetadata has been called.

     * @return the application ID

     */

    public static String getApplicationId() {

        return applicationId;

    }

    /**

     * Sets the Facebook application ID for the current app.

     * @param applicationId the application ID

     */

    public static void setApplicationId(String applicationId) {

        Settings.applicationId = applicationId;

    }

    /**

     * Gets the client token for the current app. This will be null unless explicitly set or unless

     * loadDefaultsFromMetadata has been called.

     * @return the client token

     */

    public static String getClientToken() {

        return appClientToken;

    }

    /**

     * Sets the Facebook client token for the current app.

     * @param clientToken the client token

     */

    public static void setClientToken(String clientToken) {

        appClientToken = clientToken;

    }

}