+ * 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/android/KMAPro/facebookSDK/src/main/java/com/facebook/NativeAppCallAttachmentStore.java b/android/KMAPro/facebookSDK/src/main/java/com/facebook/NativeAppCallAttachmentStore.java
new file mode 100644
index 0000000000..dc41086562
--- /dev/null
+++ b/android/KMAPro/facebookSDK/src/main/java/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+ * Returns the Date at which the current token will expire. + *
+ *+ * Note that Session automatically attempts to extend the lifetime of Tokens + * as needed when Facebook requests are made. + *
+ * + * @return the Date at which the current token will expire, or null if there is no access token + */ + public final Date getExpirationDate() { + synchronized (this.lock) { + return (this.tokenInfo == null) ? null : this.tokenInfo.getExpires(); + } + } + + /** + *+ * Returns the list of permissions associated with the session. + *
+ *+ * If there is a valid token, this represents the permissions granted by + * that token. This can change during calls to + * {@link #requestNewReadPermissions} + * or {@link #requestNewPublishPermissions}. + *
+ * + * @return the list of permissions associated with the session, or null if there is no access token + */ + public final List+ * Returns whether a particular permission has been granted + *
+ * + * @param permission The permission to check for + * @return true if the permission is granted, false otherwise + */ + public boolean isPermissionGranted(String permission) { + List+ * Returns the list of permissions that have been requested in this session but not granted + *
+ * + * @return the list of requested permissions that have been declined + */ + public final List+ * Logs a user in to Facebook. + *
+ *+ * A session may not be used with {@link Request Request} and other classes + * in the SDK until it is open. If, prior to calling open, the session is in + * the {@link SessionState#CREATED_TOKEN_LOADED CREATED_TOKEN_LOADED} + * state, and the requested permissions are a subset of the previously authorized + * permissions, then the Session becomes usable immediately with no user interaction. + *
+ *+ * The permissions associated with the openRequest passed to this method must + * be read permissions only (or null/empty). It is not allowed to pass publish + * permissions to this method and will result in an exception being thrown. + *
+ *+ * Any open method must be called at most once, and cannot be called after the + * Session is closed. Calling the method at an invalid time will result in + * UnsuportedOperationException. + *
+ * + * @param openRequest the open request, can be null only if the Session is in the + * {@link SessionState#CREATED_TOKEN_LOADED CREATED_TOKEN_LOADED} state + * @throws FacebookException if any publish or manage permissions are requested + */ + public final void openForRead(OpenRequest openRequest) { + open(openRequest, SessionAuthorizationType.READ); + } + + /** + *+ * Logs a user in to Facebook. + *
+ *+ * A session may not be used with {@link Request Request} and other classes + * in the SDK until it is open. If, prior to calling open, the session is in + * the {@link SessionState#CREATED_TOKEN_LOADED CREATED_TOKEN_LOADED} + * state, and the requested permissions are a subset of the previously authorized + * permissions, then the Session becomes usable immediately with no user interaction. + *
+ *+ * The permissions associated with the openRequest passed to this method must + * be publish or manage permissions only and must be non-empty. Any read permissions + * will result in a warning, and may fail during server-side authorization. Also, an application + * must have at least basic read permissions prior to requesting publish permissions, so + * this method should only be used if the application knows that the user has already granted + * read permissions to the application; otherwise, openForRead should be used, followed by a + * call to requestNewPublishPermissions. For more information on this flow, see + * https://developers.facebook.com/docs/facebook-login/permissions/. + *
+ *+ * Any open method must be called at most once, and cannot be called after the + * Session is closed. Calling the method at an invalid time will result in + * UnsuportedOperationException. + *
+ * + * @param openRequest the open request, can be null only if the Session is in the + * {@link SessionState#CREATED_TOKEN_LOADED CREATED_TOKEN_LOADED} state + * @throws FacebookException if the passed in request is null or has no permissions set. + */ + public final void openForPublish(OpenRequest openRequest) { + open(openRequest, SessionAuthorizationType.PUBLISH); + } + + /** + * Opens a session based on an existing Facebook access token. This method should be used + * only in instances where an application has previously obtained an access token and wishes + * to import it into the Session/TokenCachingStrategy-based session-management system. An + * example would be an application which previously did not use the Facebook SDK for Android + * and implemented its own session-management scheme, but wishes to implement an upgrade path + * for existing users so they do not need to log in again when upgrading to a version of + * the app that uses the SDK. + * + * No validation is done that the token, token source, or permissions are actually valid. + * It is the caller's responsibility to ensure that these accurately reflect the state of + * the token that has been passed in, or calls to the Facebook API may fail. + * + * @param accessToken the access token obtained from Facebook + * @param callback a callback that will be called when the session status changes; may be null + */ + public final void open(AccessToken accessToken, StatusCallback callback) { + synchronized (this.lock) { + if (pendingAuthorizationRequest != null) { + throw new UnsupportedOperationException( + "Session: an attempt was made to open a session that has a pending request."); + } + + if (state.isClosed()) { + throw new UnsupportedOperationException( + "Session: an attempt was made to open a previously-closed session."); + } else if (state != SessionState.CREATED && state != SessionState.CREATED_TOKEN_LOADED) { + throw new UnsupportedOperationException( + "Session: an attempt was made to open an already opened session."); + } + + if (callback != null) { + addCallback(callback); + } + + this.tokenInfo = accessToken; + + if (this.tokenCachingStrategy != null) { + this.tokenCachingStrategy.save(accessToken.toCacheBundle()); + } + + final SessionState oldState = state; + state = SessionState.OPENED; + this.postStateChange(oldState, state, null); + } + + autoPublishAsync(); + } + + /** + *+ * Issues a request to add new read permissions to the Session. + *
+ *+ * If successful, this will update the set of permissions on this session to + * match the newPermissions. If this fails, the Session remains unchanged. + *
+ *+ * The permissions associated with the newPermissionsRequest passed to this method must + * be read permissions only (or null/empty). It is not allowed to pass publish + * permissions to this method and will result in an exception being thrown. + *
+ * + * @param newPermissionsRequest the new permissions request + */ + public final void requestNewReadPermissions(NewPermissionsRequest newPermissionsRequest) { + requestNewPermissions(newPermissionsRequest, SessionAuthorizationType.READ); + } + + /** + *+ * Issues a request to add new publish or manage permissions to the Session. + *
+ *+ * If successful, this will update the set of permissions on this session to + * match the newPermissions. If this fails, the Session remains unchanged. + *
+ *+ * The permissions associated with the newPermissionsRequest passed to this method must + * be publish or manage permissions only and must be non-empty. Any read permissions + * will result in a warning, and may fail during server-side authorization. + *
+ * + * @param newPermissionsRequest the new permissions request + */ + public final void requestNewPublishPermissions(NewPermissionsRequest newPermissionsRequest) { + requestNewPermissions(newPermissionsRequest, SessionAuthorizationType.PUBLISH); + } + + /** + *+ * Issues a request to refresh the permissions on the session. + *
+ *+ * If successful, this will update the permissions and call the app back with + * {@link SessionState#OPENED_TOKEN_UPDATED}. The session can then be queried to see the granted and declined + * permissions. If this fails because the user has removed the app, the session will close. + *
+ */ + public final void refreshPermissions() { + Request request = new Request(this, "me/permissions"); + request.setCallback(new Request.Callback() { + @Override + public void onCompleted(Response response) { + PermissionsPair permissionsPair = handlePermissionResponse(response); + if (permissionsPair != null) { + // Update our token with the refreshed permissions + synchronized (lock) { + tokenInfo = AccessToken.createFromTokenWithRefreshedPermissions(tokenInfo, + permissionsPair.getGrantedPermissions(), permissionsPair.getDeclinedPermissions()); + postStateChange(state, SessionState.OPENED_TOKEN_UPDATED, null); + } + } + } + }); + request.executeAsync(); + } + + /** + * Internal helper class that is used to hold two different permission lists (granted and declined) + */ + static class PermissionsPair { + List