com.twitter.sdk.android.core.TwitterCore Java Examples

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    TwitterSession activeSession = TwitterCore.getInstance().getSessionManager().getActiveSession();
    if (activeSession != null) {
        handleSuccess(activeSession);
    } else {
        getTwitterAuthClient().authorize(this, new Callback<TwitterSession>() {
            @Override
            public void success(Result<TwitterSession> result) {
                startLoading();
                handleSuccess(result.data);
            }

            @Override
            public void failure(TwitterException exception) {
                handleError(exception);
            }
        });
    }
}
 

private void handleSuccess(final TwitterSession session) {
    TwitterApiClient twitterApiClient = TwitterCore.getInstance().getApiClient();
    AccountService accountService = twitterApiClient.getAccountService();
    call = accountService.verifyCredentials(false, true, true);
    call.enqueue(new Callback<User>() {
        @Override
        public void success(Result<User> userResult) {
            SocialMediaUser user = new SocialMediaUser();
            User data = userResult.data;
            user.setUserId(String.valueOf(data.getId()));
            user.setAccessToken(session.getAuthToken().token);
            user.setProfilePictureUrl(String.format(PROFILE_PIC_URL, data.screenName));
            user.setEmail(data.email != null ? data.email : "");
            user.setFullName(data.name);
            user.setUsername(data.screenName);
            user.setPageLink(String.format(PAGE_LINK, data.screenName));
            handleSuccess(SocialMediaSignUp.SocialMediaType.TWITTER, user);
        }

        public void failure(TwitterException error) {
            handleError(error);
        }
    });
}
 

public Observable<com.zedeff.twittererer.models.User> getMyDetails() {
    return Observable.create(subscriber -> {
        Callback<User> callback = new Callback<User>() {
            @Override
            public void success(Result<User> result) {
                Log.i(TAG, "Got your details, pal!");
                subscriber.onNext(new com.zedeff.twittererer.models.User(result.data.name, result.data.screenName, result.data.profileImageUrl));
            }

            @Override
            public void failure(TwitterException e) {
                Log.e(TAG, e.getMessage(), e);
                subscriber.onError(e);
            }
        };

        getService(UserService.class).show(TwitterCore.getInstance().getSessionManager().getActiveSession().getUserId()).enqueue(callback);
    });
}
 

@Override
protected void setUp() throws Exception {
    super.setUp();
    createMocks();

    // Initialize Fabric with mock executor so that kit#doInBackground() will not be called
    // during kit initialization.
    final TwitterConfig config = new TwitterConfig.Builder(getContext())
            .logger(new DefaultLogger(Log.DEBUG))
            .executorService(mock(ThreadPoolExecutor.class))
            .build();

    Twitter.initialize(config);

    final TwitterCore twitterCore = TwitterCoreTestUtils.createTwitterCore(
            new TwitterAuthConfig("", ""), clients, apiClient);

    tweetUi = TweetUi.getInstance();
    final TweetRepository tweetRepository = new TweetRepository(mainHandler,
            mock(SessionManager.class), twitterCore);
    tweetUi.setTweetRepository(tweetRepository);
    tweetUi.setImageLoader(picasso);
}
 

/**
 * Requests authorization.
 *
 * @param activity The {@link android.app.Activity} context to use for the authorization flow.
 * @param callback The callback interface to invoke when authorization completes.
 * @throws java.lang.IllegalArgumentException if activity or callback is null.
 */
public void authorize(Activity activity, Callback<TwitterSession> callback) {
    if (activity == null) {
        throw new IllegalArgumentException("Activity must not be null.");
    }
    if (callback == null) {
        throw new IllegalArgumentException("Callback must not be null.");
    }

    if (activity.isFinishing()) {
        Twitter.getLogger()
                .e(TwitterCore.TAG, "Cannot authorize, activity is finishing.", null);
    } else {
        handleAuthorize(activity, callback);
    }
}
 

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.tw__activity_oauth);

    spinner = findViewById(R.id.tw__spinner);
    webView = findViewById(R.id.tw__web_view);

    final boolean showProgress;
    if (savedInstanceState != null) {
        showProgress = savedInstanceState.getBoolean(STATE_PROGRESS, false);
    } else {
        showProgress = true;
    }
    spinner.setVisibility(showProgress ? View.VISIBLE : View.GONE);

    final TwitterCore kit = TwitterCore.getInstance();
    oAuthController = new OAuthController(spinner, webView,
            getIntent().getParcelableExtra(EXTRA_AUTH_CONFIG),
            new OAuth1aService(kit, new TwitterApi()), this);
    oAuthController.startAuth();
}
 

/**
 * Package private for testing.
 */
Callback<OAuthResponse> newRequestTempTokenCallback() {
    return new Callback<OAuthResponse>() {
        @Override
        public void success(Result<OAuthResponse> result) {
            requestToken = result.data.authToken;
            final String authorizeUrl = oAuth1aService.getAuthorizeUrl(requestToken);
            // Step 2. Redirect user to web view to complete authorization flow.
            Twitter.getLogger().d(TwitterCore.TAG,
                    "Redirecting user to web view to complete authorization flow");
            setUpWebView(webView,
                    new OAuthWebViewClient(oAuth1aService.buildCallbackUrl(authConfig),
                            OAuthController.this), authorizeUrl, new OAuthWebChromeClient());
        }

        @Override
        public void failure(TwitterException error) {
            Twitter.getLogger().e(TwitterCore.TAG,
                    "Failed to get request token", error);
            // Create new exception that can be safely serialized since Retrofit errors may
            // throw a NotSerializableException.
            handleAuthError(AuthHandler.RESULT_CODE_ERROR,
                    new TwitterAuthException("Failed to get request token"));
        }
    };
}
 

private void handleWebViewSuccess(Bundle bundle) {
    Twitter.getLogger().d(TwitterCore.TAG, "OAuth web view completed successfully");
    if (bundle != null) {
        final String verifier = bundle.getString(OAuthConstants.PARAM_VERIFIER);
        if (verifier != null) {
            // Step 3. Convert the request token to an access token.
            Twitter.getLogger().d(TwitterCore.TAG,
                    "Converting the request token to an access token.");
            oAuth1aService.requestAccessToken(newRequestAccessTokenCallback(),
                    requestToken, verifier);
            return;
        }
    }

    // If we get here, we failed to complete authorization.
    Twitter.getLogger().e(TwitterCore.TAG,
            "Failed to get authorization, bundle incomplete " + bundle, null);
    handleAuthError(AuthHandler.RESULT_CODE_ERROR,
            new TwitterAuthException("Failed to get authorization, bundle incomplete"));
}
 

/**
 * Package private for testing.
 */
Callback<OAuthResponse> newRequestAccessTokenCallback() {
    return new Callback<OAuthResponse>() {
        @Override
        public void success(Result<OAuthResponse> result) {
            final Intent data = new Intent();
            final OAuthResponse response = result.data;
            data.putExtra(AuthHandler.EXTRA_SCREEN_NAME, response.userName);
            data.putExtra(AuthHandler.EXTRA_USER_ID, response.userId);
            data.putExtra(AuthHandler.EXTRA_TOKEN, response.authToken.token);
            data.putExtra(AuthHandler.EXTRA_TOKEN_SECRET,
                    response.authToken.secret);
            listener.onComplete(Activity.RESULT_OK, data);
        }

        @Override
        public void failure(TwitterException error) {
            Twitter.getLogger().e(TwitterCore.TAG, "Failed to get access token", error);
            // Create new exception that can be safely serialized since Retrofit errors may
            // throw a NotSerializableException.
            handleAuthError(AuthHandler.RESULT_CODE_ERROR,
                    new TwitterAuthException("Failed to get access token"));
        }
    };
}
 

OAuthService(TwitterCore twitterCore, TwitterApi api) {
    this.twitterCore = twitterCore;
    this.api = api;
    userAgent = TwitterApi.buildUserAgent(CLIENT_NAME, twitterCore.getVersion());

    final OkHttpClient client = new OkHttpClient.Builder()
            .addInterceptor(chain -> {
                final Request request = chain.request().newBuilder()
                        .header("User-Agent", getUserAgent())
                        .build();
                return chain.proceed(request);
            })
            .certificatePinner(OkHttpClientHelper.getCertificatePinner())
            .build();

    retrofit = new Retrofit.Builder()
            .baseUrl(getApi().getBaseHostUrl())
            .client(client)
            .addConverterFactory(GsonConverterFactory.create())
            .build();
}
 

@Before
public void setUp() throws Exception {
    anyIds.add(anyId);
    mockTwitterCore = mock(TwitterCore.class);
    mockApiClient = mock(TwitterApiClient.class);
    mockStatusesService = mock(StatusesService.class, Mockito.RETURNS_MOCKS);
    when(mockApiClient.getStatusesService()).thenReturn(mockStatusesService);
    mockFavoriteService = mock(FavoriteService.class, Mockito.RETURNS_MOCKS);
    when(mockApiClient.getFavoriteService()).thenReturn(mockFavoriteService);
    when(mockTwitterCore.getApiClient(any(TwitterSession.class))).thenReturn(mockApiClient);
    when(mockTwitterCore.getApiClient()).thenReturn(mockApiClient);
    mockSessionManager = mock(SessionManager.class);
    when(mockSessionManager.getActiveSession()).thenReturn(mock(TwitterSession.class));
    mockHandler = mock(Handler.class);
    tweetRepository = new TweetRepository(mockHandler, mockSessionManager, mockTwitterCore);
}
 

void launchComposer(Uri uri) {
    final TwitterSession session = TwitterCore.getInstance().getSessionManager()
            .getActiveSession();
    final Intent intent = new ComposerActivity.Builder(TweetComposerMainActivity.this)
            .session(session)
            .image(uri)
            .text("Tweet from TwitterKit!")
            .hashtags("#twitter")
            .createIntent();
    startActivity(intent);
}
 

TweetRepository(Handler mainHandler, SessionManager<TwitterSession> userSessionManagers,
        TwitterCore twitterCore) {
    this.twitterCore = twitterCore;
    this.mainHandler = mainHandler;
    this.userSessionManagers = userSessionManagers;
    tweetCache = new LruCache<>(DEFAULT_CACHE_SIZE);
    formatCache = new LruCache<>(DEFAULT_CACHE_SIZE);
}
 

@Before
public void setUp() throws Exception {
    mockContext = mock(Context.class);
    when(mockContext.getPackageName()).thenReturn(getClass().getPackage().toString());

    mockTwitterCore = mock(TwitterCore.class);
    mockAuthConfig = mock(TwitterAuthConfig.class);
    when(mockAuthConfig.getRequestCode()).thenReturn(TEST_REQUEST_CODE);
    mockSessionManager = mock(SessionManager.class);
    mockAuthState = mock(AuthState.class);
    mockCallback = mock(Callback.class);

    authClient = new TwitterAuthClient(mockTwitterCore, mockAuthConfig, mockSessionManager,
            mockAuthState);
}
 

SearchTimeline(TwitterCore twitterCore, String query, Geocode geocode, String resultType,
               String languageCode, Integer maxItemsPerRequest, String untilDate) {
    this.twitterCore = twitterCore;
    this.languageCode = languageCode;
    this.maxItemsPerRequest = maxItemsPerRequest;
    this.untilDate = untilDate;
    this.resultType = resultType;
    // if the query is non-null append the filter Retweets modifier
    this.query = query == null ? null : query + FILTER_RETWEETS;
    this.geocode = geocode;
}
 

UserTimeline(TwitterCore twitterCore, Long userId, String screenName,
             Integer maxItemsPerRequest, Boolean includeReplies, Boolean includeRetweets) {
    this.twitterCore = twitterCore;
    this.userId = userId;
    this.screenName = screenName;
    this.maxItemsPerRequest = maxItemsPerRequest;
    // null includeReplies should default to false
    this.includeReplies = includeReplies == null ? false : includeReplies;
    this.includeRetweets = includeRetweets;
}
 

@Override
    public void onCreate() {
        super.onCreate();
        TwitterAuthConfig authConfig = new TwitterAuthConfig(TWITTER_KEY, TWITTER_SECRET);
//        Fabric.with(this, new TwitterCore(authConfig), new Digits());
        Fabric.with(this, new TwitterCore(authConfig),new TweetComposer());
    }
 

private void initTwitterSearch() {
    core = TwitterCore.getInstance();
    session = core.getSessionManager().getActiveSession();
    if (session != null) {
        client = core.getApiClient(session);
    }
    else {
        client = core.getGuestApiClient();
    }

    if (client != null) {
        doSearch();
    }
}
 

@SuppressLint("CheckResult")
@Override
public void fetchUserInfo(final BaseToken token) {
    mSubscribe = Flowable.create(new FlowableOnSubscribe<TwitterUser>() {
        @Override
        public void subscribe(@NonNull FlowableEmitter<TwitterUser> userEmitter) {

            TwitterApiClient apiClient = TwitterCore.getInstance().getApiClient();
            Call<User> userCall = apiClient.getAccountService().verifyCredentials(true, false, false);

            try {
                Response<User> execute = userCall.execute();
                userEmitter.onNext(new TwitterUser(execute.body()));
                userEmitter.onComplete();
            } catch (Exception e) {
                ShareLogger.e(ShareLogger.INFO.FETCH_USER_INOF_ERROR);
                userEmitter.onError(e);
            }
        }
    }, BackpressureStrategy.DROP)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Consumer<TwitterUser>() {
                @Override
                public void accept(@NonNull TwitterUser user) {
                    mLoginListener.loginSuccess(new LoginResultData(LoginPlatform.TWITTER, token, user));
                    LoginUtil.recycle();
                }
            }, new Consumer<Throwable>() {
                @Override
                public void accept(@NonNull Throwable throwable) {
                    mLoginListener.loginFailure(new Exception(throwable), ShareLogger.INFO.ERR_FETCH_CODE);
                    LoginUtil.recycle();
                }
            });
}
 

@Override
public void logout() {
    TwitterSession twitterSession = TwitterCore.getInstance().getSessionManager().getActiveSession();
    if (twitterSession != null) {
        TwitterCore.getInstance().getSessionManager().clearActiveSession();
        loginButton.get().setEnabled(true);
    }
}
 

private void checkTwitterCoreAndEnable() {
    //Default (Enabled) in edit mode
    if (isInEditMode()) return;

    try {
        TwitterCore.getInstance();
    } catch (IllegalStateException ex) {
        //Disable if TwitterCore hasn't started
        Twitter.getLogger().e(TAG, ex.getMessage());
        setEnabled(false);
    }
}
 

TwitterListTimeline(TwitterCore twitterCore, Long listId, String slug, Long ownerId,
    String ownerScreenName, Integer maxItemsPerRequest, Boolean includeRetweets) {
    this.twitterCore = twitterCore;
    this.listId = listId;
    this.slug = slug;
    this.ownerId = ownerId;
    this.ownerScreenName = ownerScreenName;
    this.maxItemsPerRequest = maxItemsPerRequest;
    this.includeRetweets = includeRetweets;
}
 

@Before
public void setUp() {
    twitterCore = mock(TwitterCore.class);
    apiClient = mock(TwitterApiClient.class);
    listService = mock(ListService.class, new MockCallAnswer());

    when(apiClient.getListService()).thenReturn(listService);
    when(twitterCore.getApiClient()).thenReturn(apiClient);
}
 

@Before
public void setUp() {
    twitterCore = mock(TwitterCore.class);
    apiClient = mock(TwitterApiClient.class);
    statusesService = mock(StatusesService.class, new MockCallAnswer());

    when(apiClient.getStatusesService()).thenReturn(statusesService);
    when(twitterCore.getApiClient()).thenReturn(apiClient);
}
 

@Before
public void setUp() throws Exception {
    testUserMap.put(TEST_USER_1.id, TEST_USER_1);
    testUserMap.put(TEST_USER_2.id, TEST_USER_2);
    testTweetMap.put(TEST_TWEET_1.id, TEST_TWEET_1);
    testTweetMap.put(TEST_TWEET_2.id, TEST_TWEET_2);
    testTweetMap.put(TEST_TWEET_QUOTE.id, TEST_TWEET_QUOTE);
    // testItems order Test Tweet 1, then 2
    testItems.add(new TwitterCollection.TimelineItem(
            new TwitterCollection.TimelineItem.TweetItem(5858L)));
    testItems.add(new TwitterCollection.TimelineItem(
            new TwitterCollection.TimelineItem.TweetItem(8585L)));
    testItems.add(new TwitterCollection.TimelineItem(
            new TwitterCollection.TimelineItem.TweetItem(858909L)));
    // testItemsRev orders Test Tweet 2, then 1
    testItemsRev.add(new TwitterCollection.TimelineItem(
            new TwitterCollection.TimelineItem.TweetItem(858909L)));
    testItemsRev.add(new TwitterCollection.TimelineItem(
            new TwitterCollection.TimelineItem.TweetItem(8585L)));
    testItemsRev.add(new TwitterCollection.TimelineItem(
            new TwitterCollection.TimelineItem.TweetItem(5858L)));

    twitterCore = mock(TwitterCore.class);
    apiClient = mock(TwitterApiClient.class);
    collectionService = mock(CollectionService.class, new MockCallAnswer());

    when(apiClient.getCollectionService()).thenReturn(collectionService);
    when(twitterCore.getApiClient()).thenReturn(apiClient);
}
 

@Before
public void setUp() {
    twitterCore = mock(TwitterCore.class);
    apiClient = mock(TwitterApiClient.class);
    searchService = mock(SearchService.class, new MockCallAnswer());

    when(apiClient.getSearchService()).thenReturn(searchService);
    when(twitterCore.getApiClient()).thenReturn(apiClient);
}
 

public boolean beginAuthorize(Activity activity, AuthHandler authHandler) {
    boolean result = false;
    if (isAuthorizeInProgress()) {
        Twitter.getLogger().w(TwitterCore.TAG, "Authorize already in progress");
    } else if (authHandler.authorize(activity)) {
        result = authHandlerRef.compareAndSet(null, authHandler);
        if (!result) {
            Twitter.getLogger().w(TwitterCore.TAG, "Failed to update authHandler, authorize"
                    + " already in progress.");
        }
    }
    return result;
}
 

TwitterAuthClient(TwitterCore twitterCore, TwitterAuthConfig authConfig,
                  SessionManager<TwitterSession> sessionManager, AuthState authState) {
    this.twitterCore = twitterCore;
    this.authState = authState;
    this.authConfig = authConfig;
    this.sessionManager = sessionManager;
}
 

private boolean authorizeUsingSSO(Activity activity, CallbackWrapper callbackWrapper) {
    if (SSOAuthHandler.isAvailable(activity)) {
        Twitter.getLogger().d(TwitterCore.TAG, "Using SSO");
        return authState.beginAuthorize(activity,
                new SSOAuthHandler(authConfig, callbackWrapper, authConfig.getRequestCode()));
    } else {
        return false;
    }
}
 

/**
 * Call this method when {@link android.app.Activity#onActivityResult(int, int, Intent)}
 * is called to complete the authorization flow.
 *
 * @param requestCode the request code used for SSO
 * @param resultCode the result code returned by the SSO activity
 * @param data the result data returned by the SSO activity
 */
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    Twitter.getLogger().d(TwitterCore.TAG,
            "onActivityResult called with " + requestCode + " " + resultCode);
    if (!authState.isAuthorizeInProgress()) {
        Twitter.getLogger().e(TwitterCore.TAG, "Authorize not in progress", null);
    } else {
        final AuthHandler authHandler = authState.getAuthHandler();
        if (authHandler != null &&
                authHandler.handleOnActivityResult(requestCode, resultCode, data)) {
            authState.endAuthorize();
        }
    }
}