+ * The AppEventsLogger class allows the developer to log various types of events back to Facebook. In order to log + * events, the app must create an instance of this class via a {@link #newLogger newLogger} method, and then call + * the various "log" methods off of that. + *
+ *+ * This client-side event logging is then available through Facebook App Insights + * and for use with Facebook Ads conversion tracking and optimization. + *
+ *+ * The AppEventsLogger class has a few related roles: + *
+ * {@code
+ *
+ * Do not start this activity directly.
+ */
+public class LoginActivity extends Activity {
+ static final String RESULT_KEY = "com.facebook.LoginActivity:Result";
+
+ private static final String TAG = LoginActivity.class.getName();
+ private static final String NULL_CALLING_PKG_ERROR_MSG =
+ "Cannot call LoginActivity with a null calling package. " +
+ "This can occur if the launchMode of the caller is singleInstance.";
+ private static final String SAVED_CALLING_PKG_KEY = "callingPackage";
+ private static final String SAVED_AUTH_CLIENT = "authorizationClient";
+ private static final String EXTRA_REQUEST = "request";
+
+ private String callingPackage;
+ private AuthorizationClient authorizationClient;
+ private AuthorizationClient.AuthorizationRequest request;
+
+ @Override
+ public void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.com_facebook_login_activity_layout);
+
+ if (savedInstanceState != null) {
+ callingPackage = savedInstanceState.getString(SAVED_CALLING_PKG_KEY);
+ authorizationClient = (AuthorizationClient) savedInstanceState.getSerializable(SAVED_AUTH_CLIENT);
+ } else {
+ callingPackage = getCallingPackage();
+ authorizationClient = new AuthorizationClient();
+ request = (AuthorizationClient.AuthorizationRequest) getIntent().getSerializableExtra(EXTRA_REQUEST);
+ }
+
+ authorizationClient.setContext(this);
+ authorizationClient.setOnCompletedListener(new AuthorizationClient.OnCompletedListener() {
+ @Override
+ public void onCompleted(AuthorizationClient.Result outcome) {
+ onAuthClientCompleted(outcome);
+ }
+ });
+ authorizationClient.setBackgroundProcessingListener(new AuthorizationClient.BackgroundProcessingListener() {
+ @Override
+ public void onBackgroundProcessingStarted() {
+ findViewById(R.id.com_facebook_login_activity_progress_bar).setVisibility(View.VISIBLE);
+ }
+
+ @Override
+ public void onBackgroundProcessingStopped() {
+ findViewById(R.id.com_facebook_login_activity_progress_bar).setVisibility(View.GONE);
+ }
+ });
+ }
+
+ private void onAuthClientCompleted(AuthorizationClient.Result outcome) {
+ request = null;
+
+ int resultCode = (outcome.code == AuthorizationClient.Result.Code.CANCEL) ?
+ RESULT_CANCELED : RESULT_OK;
+
+ Bundle bundle = new Bundle();
+ bundle.putSerializable(RESULT_KEY, outcome);
+
+ Intent resultIntent = new Intent();
+ resultIntent.putExtras(bundle);
+ setResult(resultCode, resultIntent);
+
+ finish();
+ }
+
+ @Override
+ public void onResume() {
+ super.onResume();
+
+ // If the calling package is null, this generally means that the callee was started
+ // with a launchMode of singleInstance. Unfortunately, Android does not allow a result
+ // to be set when the callee is a singleInstance, so we log an error and return.
+ if (callingPackage == null) {
+ Log.e(TAG, NULL_CALLING_PKG_ERROR_MSG);
+ finish();
+ return;
+ }
+
+ authorizationClient.startOrContinueAuth(request);
+ }
+
+ @Override
+ public void onPause() {
+ super.onPause();
+
+ authorizationClient.cancelCurrentHandler();
+ findViewById(R.id.com_facebook_login_activity_progress_bar).setVisibility(View.GONE);
+ }
+
+ @Override
+ public void onSaveInstanceState(Bundle outState) {
+ super.onSaveInstanceState(outState);
+
+ outState.putString(SAVED_CALLING_PKG_KEY, callingPackage);
+ outState.putSerializable(SAVED_AUTH_CLIENT, authorizationClient);
+ }
+
+ @Override
+ protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+ authorizationClient.onActivityResult(requestCode, resultCode, data);
+ }
+
+ static Bundle populateIntentExtras(AuthorizationClient.AuthorizationRequest request) {
+ Bundle extras = new Bundle();
+ extras.putSerializable(EXTRA_REQUEST, request);
+ return extras;
+ }
+}
diff --git a/third-party-libs/facebook-sdk/facebook/src/com/facebook/NativeAppCallAttachmentStore.java b/third-party-libs/facebook-sdk/facebook/src/com/facebook/NativeAppCallAttachmentStore.java
new file mode 100644
index 0000000..dc41086
--- /dev/null
+++ b/third-party-libs/facebook-sdk/facebook/src/com/facebook/NativeAppCallAttachmentStore.java
@@ -0,0 +1,225 @@
+/**
+ * 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.Context;
+import android.graphics.Bitmap;
+import android.util.Log;
+import com.facebook.internal.Utility;
+import com.facebook.internal.Validate;
+
+import java.io.*;
+import java.net.URLEncoder;
+import java.util.*;
+
+/**
+ * This class works in conjunction with {@link NativeAppCallContentProvider} to allow apps to attach binary + * attachments (e.g., images) to native dialogs launched via the {@link com.facebook.widget.FacebookDialog} + * class. It stores attachments in temporary files and allows the Facebook application to retrieve them via + * the content provider.
+ * + *Callers are generally not expected to need to use this class directly; + * see {@link com.facebook.widget.FacebookDialog.OpenGraphActionDialogBuilder#setImageAttachmentsForObject(String, + * java.util.List) OpenGraphActionDialogBuilder.setImageAttachmentsForObject} for an example of a function + * that will accept attachments, attach them to the native dialog call, and add them to the content provider + * automatically.
+ **/ +public final class NativeAppCallAttachmentStore implements NativeAppCallContentProvider.AttachmentDataSource { + private static final String TAG = NativeAppCallAttachmentStore.class.getName(); + static final String ATTACHMENTS_DIR_NAME = "com.facebook.NativeAppCallAttachmentStore.files"; + private static File attachmentsDirectory; + + /** + * Adds a number of bitmap attachments associated with a native app call. The attachments will be + * served via {@link NativeAppCallContentProvider#openFile(android.net.Uri, String) openFile}. + * + * @param context the Context the call is being made from + * @param callId the unique ID of the call + * @param imageAttachments a Map of attachment names to Bitmaps; the attachment names will be part of + * the URI processed by openFile + * @throws java.io.IOException + */ + public void addAttachmentsForCall(Context context, UUID callId, MapImplements a + * ContentProvider that can be used to provide binary attachments (e.g., images) to calls made + * via @link FacebookDialog}. The {@link NativeAppCallAttachmentStore} class provides methods to attach + * and clean up the attachments. + * + *
Note that this ContentProvider is only necessary if an application wishes to attach images, etc., that are + * stored in memory and do not have another way to be referenced by a content URI. For images obtained from, + * e.g., the Camera or Gallery, that already have a content URI associated with them, use of this class is not + * necessary.
+ * + *If an application wishes to attach images that are stored in-memory within the application, this content
+ * provider must be listed in the application's AndroidManifest.xml, and it should be named according to the
+ * pattern "com.facebook.app.NativeAppCallContentProvider{FACEBOOK_APP_ID}". See the
+ * {@link NativeAppCallContentProvider#getAttachmentUrl(String) getContentProviderName} method.
+ * Session is used to authenticate a user and manage the user's session with + * Facebook. + *
+ *+ * Sessions must be opened before they can be used to make a Request. When a + * Session is created, it attempts to initialize itself from a TokenCachingStrategy. + * Closing the session can optionally clear this cache. The Session lifecycle + * uses {@link SessionState SessionState} to indicate its state. Once a Session has + * been closed, it can't be re-opened; a new Session must be created. + *
+ *+ * Instances of Session provide state change notification via a callback + * interface, {@link Session.StatusCallback StatusCallback}. + *
+ */ +public class Session implements Serializable { + private static final long serialVersionUID = 1L; + + /** + * The logging tag used by Session. + */ + public static final String TAG = Session.class.getCanonicalName(); + + /** + * The default activity code used for authorization. + * + * @see #openForRead(OpenRequest) + * open + */ + public static final int DEFAULT_AUTHORIZE_ACTIVITY_CODE = 0xface; + + /** + * If Session authorization fails and provides a web view error code, the + * web view error code is stored in the Bundle returned from + * {@link #getAuthorizationBundle getAuthorizationBundle} under this key. + */ + public static final String WEB_VIEW_ERROR_CODE_KEY = "com.facebook.sdk.WebViewErrorCode"; + + /** + * If Session authorization fails and provides a failing url, the failing + * url is stored in the Bundle returned from {@link #getAuthorizationBundle + * getAuthorizationBundle} under this key. + */ + public static final String WEB_VIEW_FAILING_URL_KEY = "com.facebook.sdk.FailingUrl"; + + /** + * The action used to indicate that the active session has been set. This should + * be used as an action in an IntentFilter and BroadcastReceiver registered with + * the {@link android.support.v4.content.LocalBroadcastManager}. + */ + public static final String ACTION_ACTIVE_SESSION_SET = "com.facebook.sdk.ACTIVE_SESSION_SET"; + + /** + * The action used to indicate that the active session has been set to null. This should + * be used as an action in an IntentFilter and BroadcastReceiver registered with + * the {@link android.support.v4.content.LocalBroadcastManager}. + */ + public static final String ACTION_ACTIVE_SESSION_UNSET = "com.facebook.sdk.ACTIVE_SESSION_UNSET"; + + /** + * The action used to indicate that the active session has been opened. This should + * be used as an action in an IntentFilter and BroadcastReceiver registered with + * the {@link android.support.v4.content.LocalBroadcastManager}. + */ + public static final String ACTION_ACTIVE_SESSION_OPENED = "com.facebook.sdk.ACTIVE_SESSION_OPENED"; + + /** + * The action used to indicate that the active session has been closed. This should + * be used as an action in an IntentFilter and BroadcastReceiver registered with + * the {@link android.support.v4.content.LocalBroadcastManager}. + */ + public static final String ACTION_ACTIVE_SESSION_CLOSED = "com.facebook.sdk.ACTIVE_SESSION_CLOSED"; + + private static final Object STATIC_LOCK = new Object(); + private static Session activeSession; + private static volatile Context staticContext; + + // Token extension constants + private static final int TOKEN_EXTEND_THRESHOLD_SECONDS = 24 * 60 * 60; // 1 + // day + private static final int TOKEN_EXTEND_RETRY_SECONDS = 60 * 60; // 1 hour + + private static final String SESSION_BUNDLE_SAVE_KEY = "com.facebook.sdk.Session.saveSessionKey"; + private static final String AUTH_BUNDLE_SAVE_KEY = "com.facebook.sdk.Session.authBundleKey"; + private static final String PUBLISH_PERMISSION_PREFIX = "publish"; + private static final String MANAGE_PERMISSION_PREFIX = "manage"; + + private static final String BASIC_INFO_PERMISSION = "basic_info"; + + @SuppressWarnings("serial") + private static final Set