Back to project page BagOfPix.
The source code is released under:
MIT License
If you think the Android project BagOfPix listed in this page is inappropriate, such as containing malicious code/tools or violating the copyright, please email info at java2s dot com, thanks.
/** * Copyright 2010-present Facebook.//from w w w .j a v a 2 s. c om * * 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.database.Cursor; import android.net.Uri; import android.os.AsyncTask; import android.os.Handler; import android.os.Looper; import android.util.Log; import com.facebook.android.BuildConfig; import com.facebook.internal.Utility; import com.facebook.model.GraphObject; import com.facebook.internal.Validate; import org.json.JSONException; import org.json.JSONObject; import java.lang.reflect.Field; import java.util.*; import java.util.concurrent.*; import java.util.concurrent.atomic.AtomicInteger; /** * 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 final String FACEBOOK_COM = "facebook.com"; private static volatile String facebookDomain = FACEBOOK_COM; 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()); } }; /** * 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 BuildConfig.DEBUG && loggingBehaviors.contains(behavior); } } /** * 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; } /** * Manually publish install attribution to the Facebook graph. Internally handles tracking repeat calls to prevent * multiple installs being published to the graph. * @param context the current Context * @param applicationId the fb application being published. * * This method is deprecated. See {@link AppEventsLogger#activateApp(Context, String)} for more info. */ @Deprecated public static void publishInstallAsync(final Context context, final String applicationId) { publishInstallAsync(context, applicationId, null); } /** * Manually publish install attribution to the Facebook graph. Internally handles tracking repeat calls to prevent * multiple installs being published to the graph. * @param context the current Context * @param applicationId the fb application being published. * @param callback a callback to invoke with a Response object, carrying the server response, or an error. * * This method is deprecated. See {@link AppEventsLogger#activateApp(Context, String)} for more info. */ @Deprecated public 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); 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; } /** * Manually publish install attribution to the Facebook graph. Internally handles tracking repeat calls to prevent * multiple installs being published to the graph. * @param context the current Context * @param applicationId the fb application being published. * @return returns false on error. Applications should retry until true is returned. Safe to call again after * true is returned. * * This method is deprecated. See {@link AppEventsLogger#activateApp(Context, String)} for more info. */ @Deprecated public static boolean publishInstallAndWait(final Context context, final String applicationId) { Response response = publishInstallAndWaitForResponse(context, applicationId); return response != null && response.getError() == null; } /** * Manually publish install attribution to the Facebook graph. Internally handles caching repeat calls to prevent * multiple installs being published to the graph. * @param context the current Context * @param applicationId the fb application being published. * @return returns a Response object, carrying the server response, or an error. * * This method is deprecated. See {@link AppEventsLogger#activateApp(Context, String)} for more info. */ @Deprecated public static Response publishInstallAndWaitForResponse(final Context context, final String applicationId) { return publishInstallAndWaitForResponse(context, applicationId, false); } 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"); } String attributionId = Settings.getAttributionId(context.getContentResolver()); 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, attributionId, 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, graphObject, true); } } else if (attributionId == null) { throw new FacebookException("No attribution id returned from the Facebook application"); } 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.commit(); 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) { try { String [] projection = {ATTRIBUTION_ID_COLUMN_NAME}; Cursor 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)); c.close(); return attributionId; } catch (Exception e) { Log.d(TAG, "Caught unexpected exception in getAttributionId(): " + e.toString()); return null; } } /** * 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 the current Facebook migration bundle string; this string can be passed to Graph API * endpoints to specify a set of platform migrations that are explicitly turned on or off for * that call, in order to ensure compatibility between a given version of the SDK and the * Graph API. * @return the migration bundle supported by this version of the SDK */ public static String getMigrationBundle() { return FacebookSdkVersion.MIGRATION_BUNDLE; } /** * 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) { SharedPreferences preferences = context.getSharedPreferences(APP_EVENT_PREFERENCES, Context.MODE_PRIVATE); SharedPreferences.Editor editor = preferences.edit(); editor.putBoolean("limitEventUsage", limitEventUsage); editor.commit(); } }