Facebook Android SDK

import com.facebook.FacebookSdk
import com.facebook.AccessToken
import com.facebook.AccessTokenSource
import com.facebook.GraphRequest
import com.facebook.GraphResponse
import com.facebook.FacebookCallback
import com.facebook.FacebookException
import com.facebook.CallbackManager
import com.facebook.LoginStatusCallback
import com.facebook.login.LoginManager
import com.facebook.login.LoginResult
import com.facebook.login.LoginBehavior
import com.facebook.login.DefaultAudience
import com.facebook.login.LoginTargetApp
import com.facebook.login.LoginConfiguration
import com.facebook.share.ShareApi
import com.facebook.appevents.AppEventsLogger
import android.content.Context
import android.content.Intent
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.result.ActivityResultRegistryOwner
import androidx.fragment.app.Fragment
import java.util.Date
import java.util.concurrent.Executor
import java.io.File

// Initialize SDK (usually in Application.onCreate())
class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        FacebookSdk.sdkInitialize(applicationContext)
    }
}

// Basic login flow
class MainActivity : AppCompatActivity() {
    private lateinit var callbackManager: CallbackManager
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        callbackManager = CallbackManager.Factory.create()
        
        // Login with permissions
        LoginManager.getInstance().logInWithReadPermissions(
            this, 
            listOf("email", "public_profile")
        )
        
        // Register callback
        LoginManager.getInstance().registerCallback(callbackManager,
            object : FacebookCallback<LoginResult> {
                override fun onSuccess(result: LoginResult) {
                    val accessToken = result.accessToken
                    // Handle successful login
                }
                override fun onCancel() { /* Handle cancellation */ }
                override fun onError(error: FacebookException) { /* Handle error */ }
            })
    }
    
    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        callbackManager.onActivityResult(requestCode, resultCode, data)
        super.onActivityResult(requestCode, resultCode, data)
    }
}

object FacebookSdk {
    fun sdkInitialize(applicationContext: Context)
    fun sdkInitialize(applicationContext: Context, callback: InitializeCallback?)
    fun isInitialized(): Boolean
    fun getApplicationId(): String
    fun setApplicationId(applicationId: String)
    fun getApplicationName(): String?
    fun setApplicationName(applicationName: String?)
    fun getClientToken(): String
    fun setClientToken(clientToken: String?)
    fun getApplicationContext(): Context
    fun getSdkVersion(): String
    fun getGraphApiVersion(): String
    fun setGraphApiVersion(graphApiVersion: String)
    fun getAutoInitEnabled(): Boolean
    fun setAutoInitEnabled(flag: Boolean)
    fun getAutoLogAppEventsEnabled(): Boolean
    fun setAutoLogAppEventsEnabled(flag: Boolean)
    fun isDebugEnabled(): Boolean
    fun setIsDebugEnabled(enabled: Boolean)
    fun getLimitEventAndDataUsage(context: Context): Boolean
    fun setLimitEventAndDataUsage(context: Context, limitEventUsage: Boolean)
    fun getExecutor(): Executor
    fun setExecutor(executor: Executor)
    fun getGraphDomain(): String
    fun getFacebookDomain(): String
    fun setFacebookDomain(facebookDomain: String)
    fun getCacheDir(): File?
    fun setCacheDir(cacheDir: File)
    
    fun interface InitializeCallback {
        fun onInitialized()
    }
}

class AccessToken(
    accessToken: String,
    applicationId: String,
    userId: String,
    permissions: Collection<String?>?,
    declinedPermissions: Collection<String?>?,
    expiredPermissions: Collection<String?>?,
    accessTokenSource: AccessTokenSource?,
    expirationTime: Date?,
    lastRefreshTime: Date?,
    dataAccessExpirationTime: Date?,
    graphDomain: String? = "facebook"
) {
    val token: String
    val userId: String
    val applicationId: String
    val permissions: Set<String?>
    val declinedPermissions: Set<String?>
    val expiredPermissions: Set<String?>
    val expires: Date
    val lastRefresh: Date
    val dataAccessExpirationTime: Date
    val graphDomain: String?
    val source: AccessTokenSource
    val isExpired: Boolean
    val isDataAccessExpired: Boolean
    val isInstagramToken: Boolean
    
    interface AccessTokenRefreshCallback {
        fun OnTokenRefreshed(accessToken: AccessToken?)
        fun OnTokenRefreshFailed(exception: FacebookException?)
    }
    
    interface AccessTokenCreationCallback {
        fun onSuccess(token: AccessToken?)
        fun onError(error: FacebookException?)
    }
    
    companion object {
        fun getCurrentAccessToken(): AccessToken?
        fun setCurrentAccessToken(accessToken: AccessToken?)
        fun isCurrentAccessTokenActive(): Boolean
        fun isDataAccessActive(): Boolean
        fun isLoggedInWithInstagram(): Boolean
        fun expireCurrentAccessToken()
        fun refreshCurrentAccessTokenAsync()
        fun refreshCurrentAccessTokenAsync(callback: AccessTokenRefreshCallback?)
        fun createFromNativeLinkingIntent(
            intent: Intent,
            applicationId: String,
            accessTokenCallback: AccessTokenCreationCallback
        )
    }
}

class LoginManager {
    var loginBehavior: LoginBehavior
    var defaultAudience: DefaultAudience
    var authType: String
    var loginTargetApp: LoginTargetApp
    var isFamilyLogin: Boolean
    var shouldSkipAccountDeduplication: Boolean
    
    companion object {
        fun getInstance(): LoginManager
    }
    
    // Basic login methods
    fun logIn(activity: Activity, permissions: Collection<String>?)
    fun logIn(fragment: Fragment, permissions: Collection<String>?)
    fun logIn(activity: Activity, permissions: Collection<String>?, loggerID: String?)
    fun logIn(fragment: Fragment, permissions: Collection<String>?, loggerID: String?)
    
    // Read permissions login
    fun logInWithReadPermissions(activity: Activity, permissions: Collection<String>?)
    fun logInWithReadPermissions(fragment: Fragment, callbackManager: CallbackManager, permissions: Collection<String>)
    fun logInWithReadPermissions(activityResultRegistryOwner: ActivityResultRegistryOwner, callbackManager: CallbackManager, permissions: Collection<String>)
    
    // Publish permissions login  
    fun logInWithPublishPermissions(activity: Activity, permissions: Collection<String>?)
    fun logInWithPublishPermissions(fragment: Fragment, callbackManager: CallbackManager, permissions: Collection<String>)
    fun logInWithPublishPermissions(activityResultRegistryOwner: ActivityResultRegistryOwner, callbackManager: CallbackManager, permissions: Collection<String>)
    
    // Configuration login
    fun logInWithConfiguration(fragment: Fragment, loginConfig: LoginConfiguration)
    fun loginWithConfiguration(activity: Activity, loginConfig: LoginConfiguration)
    
    // Login status and reauthorization
    fun retrieveLoginStatus(context: Context, responseCallback: LoginStatusCallback)
    fun retrieveLoginStatus(context: Context, toastDurationMs: Long, responseCallback: LoginStatusCallback)
    fun reauthorizeDataAccess(activity: Activity)
    fun reauthorizeDataAccess(fragment: Fragment)
    
    // Error resolution
    fun resolveError(activity: Activity, response: GraphResponse)
    fun resolveError(fragment: Fragment, callbackManager: CallbackManager, response: GraphResponse)
    fun resolveError(activityResultRegistryOwner: ActivityResultRegistryOwner, callbackManager: CallbackManager, response: GraphResponse)
    
    // Configuration setters
    fun setLoginBehavior(loginBehavior: LoginBehavior): LoginManager
    fun setLoginTargetApp(targetApp: LoginTargetApp): LoginManager
    fun setDefaultAudience(defaultAudience: DefaultAudience): LoginManager
    fun setAuthType(authType: String): LoginManager
    fun setMessengerPageId(messengerPageId: String?): LoginManager
    fun setResetMessengerState(resetMessengerState: Boolean): LoginManager
    fun setFamilyLogin(isFamilyLogin: Boolean): LoginManager
    fun setShouldSkipAccountDeduplication(shouldSkipAccountDeduplication: Boolean): LoginManager
    
    // Callback management
    fun registerCallback(callbackManager: CallbackManager?, callback: FacebookCallback<LoginResult>?)
    fun unregisterCallback(callbackManager: CallbackManager?)
    
    // Activity result contract
    fun createLogInActivityResultContract(callbackManager: CallbackManager? = null, loggerID: String? = null): FacebookLoginActivityResultContract
    
    fun logOut()
}

class LoginButton : FacebookButtonBase {
    var permissions: List<String>
    var loginBehavior: LoginBehavior
    var defaultAudience: DefaultAudience
    
    fun setPermissions(vararg permissions: String?)
    fun registerCallback(
        callbackManager: CallbackManager, 
        callback: FacebookCallback<LoginResult>
    )
}

data class LoginResult(
    val accessToken: AccessToken,
    val recentlyGrantedPermissions: Set<String>,
    val recentlyDeniedPermissions: Set<String>
)

class GraphRequest private constructor() {
    companion object {
        fun newMeRequest(
            accessToken: AccessToken?,
            callback: GraphJSONObjectCallback?
        ): GraphRequest
        
        fun newPostRequest(
            accessToken: AccessToken?,
            graphPath: String?,
            graphObject: JSONObject?,
            callback: Callback?
        ): GraphRequest
    }
    
    fun executeAsync(): GraphRequestAsyncTask
    fun executeAndWait(): GraphResponse
    
    interface Callback {
        fun onCompleted(response: GraphResponse)
    }
}

class GraphResponse(
    request: GraphRequest,
    connection: HttpURLConnection?,
    error: FacebookRequestError?
) {
    val jsonObject: JSONObject?
    val jsonArray: JSONArray?
    val error: FacebookRequestError?
}

class ShareApi(
    content: ShareContent<*, *>,
    mode: ShareApi.Mode
) {
    enum class Mode { AUTOMATIC, NATIVE, WEB }
    
    fun share(callback: FacebookCallback<Sharer.Result>?)
    fun canShare(): Boolean
}

class ShareDialog : FacebookDialogBase<ShareContent<*, *>, ShareDialog.Result> {
    companion object {
        fun canShow(contentType: Class<out ShareContent<*, *>>): Boolean
    }
    
    fun show(content: ShareContent<*, *>)
}

abstract class ShareContent<P : ShareContent<P, E>, E : ShareContent.Builder<P, E>> {
    val contentUrl: Uri?
    val peopleIds: List<String>
    val placeId: String?
    val ref: String?
    val shareHashtag: ShareHashtag?
}

class AppEventsLogger private constructor() {
    companion object {
        fun newLogger(context: Context): AppEventsLogger
        fun activateApp(application: Application)
        fun deactivateApp(application: Application)
    }
    
    fun logEvent(eventName: String)
    fun logEvent(eventName: String, parameters: Bundle?)
    fun logEvent(eventName: String, valueToSum: Double)
    fun logEvent(eventName: String, valueToSum: Double, parameters: Bundle?)
    fun logPurchase(purchaseAmount: BigDecimal, currency: Currency)
    fun flush()
}

class AppLinkData private constructor() {
    val targetUri: Uri?
    val ref: String?
    val extras: Bundle?
    val argumentBundle: Bundle?
    
    companion object {
        fun fetchDeferredAppLinkData(
            context: Context,
            callback: CompletionHandler
        )
        
        fun createFromActivity(activity: Activity): AppLinkData?
        fun createFromAlBundle(appLinkBundle: Bundle): AppLinkData?
    }
    
    interface CompletionHandler {
        fun onDeferredAppLinkDataFetched(appLinkData: AppLinkData?)
    }
}

object MessengerUtils {
    fun openMessengerInPlayStore(context: Context)
    fun hasMessengerInstalled(context: Context): Boolean
    fun shareToMessenger(
        activity: Activity,
        requestCode: Int,
        shareToMessengerParams: ShareToMessengerParams
    )
}

class ShareToMessengerParams private constructor() {
    val uri: Uri?
    val mimeType: String?
    val metaData: Bundle?
    
    class Builder {
        fun setUri(uri: Uri): Builder
        fun setMimeType(mimeType: String): Builder
        fun setMetaData(metaData: Bundle): Builder
        fun build(): ShareToMessengerParams
    }
}

class GamingContext private constructor() {
    val identifier: String?
    
    companion object {
        fun getCurrentGamingContext(): GamingContext?
        fun switchGamingContext(
            context: Context,
            gamingContextId: String,
            callback: FacebookCallback<GamingContext>
        )
    }
}

class FriendFinderDialog : FacebookDialogBase<Void, FriendFinderDialog.Result> {
    fun show()
    
    class Result(requestId: String, to: List<String>)
}

class TournamentFetcher {
    companion object {
        fun fetchTournaments(callback: FacebookCallback<List<Tournament>>)
    }
}

class Task<TResult> private constructor() {
    val isCompleted: Boolean
    val isCancelled: Boolean
    val isFaulted: Boolean
    val result: TResult?
    val error: Exception?
    
    fun <TContinuationResult> continueWith(
        continuation: Continuation<TResult, TContinuationResult>
    ): Task<TContinuationResult>
    
    fun <TContinuationResult> onSuccess(
        continuation: Continuation<TResult, TContinuationResult>
    ): Task<TContinuationResult>
    
    companion object {
        fun <TResult> call(callable: Callable<TResult>): Task<TResult>
        fun <TResult> callInBackground(callable: Callable<TResult>): Task<TResult>
    }
}

class TaskCompletionSource<TResult> {
    val task: Task<TResult>
    
    fun setResult(result: TResult)
    fun setError(error: Exception)
    fun setCancelled()
}

enum class AccessTokenSource {
    FACEBOOK_APPLICATION_WEB,
    FACEBOOK_APPLICATION_NATIVE,
    FACEBOOK_APPLICATION_SERVICE,
    WEB_VIEW,
    CHROME_CUSTOM_TAB,
    INSTAGRAM_APPLICATION_WEB,
    INSTAGRAM_CUSTOM_CHROME_TAB,
    INSTAGRAM_WEB_VIEW
}

enum class LoginBehavior {
    NATIVE_WITH_FALLBACK,
    NATIVE_ONLY,
    WEB_ONLY,
    WEB_VIEW_ONLY,
    KATANA_ONLY,
    DIALOG_ONLY
}

enum class DefaultAudience {
    ONLY_ME,
    FRIENDS,
    EVERYONE
}

enum class LoginTargetApp {
    FACEBOOK,
    INSTAGRAM
}

enum class HttpMethod {
    GET, POST, DELETE
}

class LoginConfiguration(
    permissions: Collection<String>? = null,
    nonce: String? = null,
    codeVerifier: String? = null
) {
    val permissions: Collection<String>
    val nonce: String?
    val codeVerifier: String
}

data class LoginResult(
    val accessToken: AccessToken,
    val authenticationToken: AuthenticationToken?,
    val recentlyGrantedPermissions: Set<String>,
    val recentlyDeniedPermissions: Set<String>
)

interface LoginStatusCallback {
    fun onCompleted(accessToken: AccessToken)
    fun onFailure()
    fun onError(exception: Exception)
}

interface CallbackManager {
    fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?): Boolean
    
    object Factory {
        fun create(): CallbackManager
    }
}

interface FacebookCallback<T> {
    fun onSuccess(result: T)
    fun onCancel()
    fun onError(error: FacebookException)
}

open class FacebookException(message: String?) : RuntimeException(message)

class FacebookAuthorizationException(message: String?) : FacebookException(message)

class FacebookOperationCanceledException(message: String?) : FacebookException(message)

class FacebookServiceException(
    error: FacebookRequestError,
    errorMessage: String?
) : FacebookException(errorMessage)

class FacebookSdkNotInitializedException(message: String?) : FacebookException(message)