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

/**
 * 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);
    }
}
 

public Observable<Boolean> sendTweet(String tweetText) {
    return Observable.create(subscriber -> {
        Callback<Tweet> callback = new Callback<Tweet>() {
            @Override
            public void success(Result<Tweet> result) {
                Log.i(TAG, "Tweet tweeted");
                subscriber.onNext(true);
            }

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

        getStatusesService().update(tweetText, null, null, null, null, null, null, null, null).enqueue(callback);
    });
}
 

private void requestEmail(final TwitterSession session, final AccessToken tempToken) {
    TwitterAuthClient authClient = new TwitterAuthClient();
    authClient.requestEmail(session, new Callback<String>() {
        @Override
        public void success(Result<String> result) {
            final String email = result.data;
            if (TextUtils.isEmpty(email)) {
                logout();
                callLoginFailure("Before fetching an email, ensure that 'Request email addresses from users' is checked for your Twitter app.");
                return;
            }
            accessToken = new AccessToken.Builder(tempToken).email(email).build();
            callLoginSuccess();
        }

        @Override
        public void failure(TwitterException exception) {
            Log.e("TwitterNetwork", "Before fetching an email, ensure that 'Request email addresses from users' is checked for your Twitter app.");
            callLoginFailure(exception.getMessage());
        }
    });
}
 

@Test
public void testCallbackWrapperSuccess_iOException() throws IOException {
    final Callback<OAuthResponse> callback = new Callback<OAuthResponse>() {
        @Override
        public void success(Result<OAuthResponse> result) {
            fail();
        }

        @Override
        public void failure(TwitterException exception) {
            assertNotNull(exception);
        }
    };
    final Callback<ResponseBody> callbackWrapper = service.getCallbackWrapper(callback);
    final ResponseBody responseBody = ResponseBody.create(MediaType.parse("application/json"), "");
    callbackWrapper.success(new Result<>(responseBody, Response.success(responseBody)));
}
 

private void loadTweet() {
  LogUtils.d(TAG, "loadTweet, tweetId = " + tweetId);

  TweetUtils.loadTweet(tweetId, new Callback<Tweet>() {
    @Override
    public void success(Result<Tweet> result) {
      LogUtils.d(TAG, "loadTweet, success");
      Tweet selectedTweet = result.data;
      setTweet(selectedTweet);
      handleSuccess();
    }

    @Override
    public void failure(TwitterException exception) {
      LogUtils.d(TAG, "loadTweet, failure");
      // TODO send message
      handleError();
    }
  });
}
 

public void next(Long maxPosition) {
    if (!mTimelineStateHolder.startTimelineRequest()) {
        return;
    }
    mTimeline.next(maxPosition, new Callback<TimelineResult<Tweet>>() {
        @Override
        public void success(Result<TimelineResult<Tweet>> result) {
            mTimelineStateHolder.setNextCursor(result.data.timelineCursor);
            mTweets.addAll(0, result.data.items);

            mNextSubject.onNext(new DataSetInsertResult(0, result.data.items.size()));

            mTimelineStateHolder.finishTimelineRequest();
        }

        @Override
        public void failure(TwitterException e) {
            mNextSubject.onError(e);

            mTimelineStateHolder.finishTimelineRequest();
        }
    });
}
 

private void fetchPrevious(Long minPosition) {
    mTimeline.previous(minPosition, new Callback<TimelineResult<Tweet>>() {
        @Override
        public void success(Result<TimelineResult<Tweet>> result) {
            mTimelineStateHolder.setPreviousCursor(result.data.timelineCursor);
            if (mRefreshing) {
                mTweets.clear();
            }
            int position = mTweets.size();
            mTweets.addAll(result.data.items);

            mPreviousSubject.onNext(new DataSetInsertResult(position, result.data.items.size()));

            mTimelineStateHolder.finishTimelineRequest();
            mRefreshing = false;
        }

        @Override
        public void failure(TwitterException e) {
            mPreviousSubject.onError(e);

            mTimelineStateHolder.finishTimelineRequest();
            mRefreshing = false;
        }
    });
}
 

@Test
public void testBeginAuthorize_authHandlerCompareAndSetFails() {
    final AuthState authState = new AuthState();
    final boolean result = authState.beginAuthorize(mockActivity,
            new AuthHandler(mock(TwitterAuthConfig.class), mock(Callback.class),
                    TwitterAuthConfig.DEFAULT_AUTH_REQUEST_CODE) {
                @Override
                public boolean authorize(Activity activity) {
                    // We use this opportunity to set authState's authHandlerRef so that we
                    // can verify behavior when compare and set fails. This is done because
                    // AtomicReference has methods that cannot be mocked.
                    authState.authHandlerRef.set(mock(AuthHandler.class));
                    return true;
                }
            });
    assertFalse(result);
}
 

public void testConstructor_withActionCallback() {
    final TimelineDelegate<Tweet> mockTimelineDelegate = mock(TestTimelineDelegate.class);
    final Callback<Tweet> mockCallback = mock(Callback.class);
    final TweetUi tweetUi = mock(TweetUi.class);
    listAdapter = new TweetTimelineListAdapter(getContext(), mockTimelineDelegate, ANY_STYLE,
            mockCallback, tweetUi);
    // assert that
    // - developer callback wrapped in a ReplaceTweetCallback
    if (listAdapter.actionCallback instanceof TweetTimelineListAdapter.ReplaceTweetCallback) {
        final TweetTimelineListAdapter.ReplaceTweetCallback replaceCallback
                = (TweetTimelineListAdapter.ReplaceTweetCallback) listAdapter.actionCallback;
        assertEquals(mockTimelineDelegate, replaceCallback.delegate);
        assertEquals(mockCallback, replaceCallback.cb);
    } else {
        fail("Expected actionCallback to be wrapped in ReplaceTweetCallback");
    }
}
 

@Test
public void testCallbackWrapperSuccess_noToken() throws IOException {
    final String response = "oauth_token_secret=PbKfYqSryyeKDWz4ebtY3o5ogNLG11WJuZBc9fQrQo&"
            + "screen_name=test&user_id=1";
    final Callback<OAuthResponse> callback = new Callback<OAuthResponse>() {
        @Override
        public void success(Result<OAuthResponse> result) {
            fail();
        }

        @Override
        public void failure(TwitterException exception) {
            assertNotNull(exception);
        }
    };
    setupCallbackWrapperTest(response, callback);
}
 

@Test
public void testCallbackWrapperSuccess() throws IOException {
    final String response = "oauth_token=7588892-kagSNqWge8gB1WwE3plnFsJHAZVfxWD7Vb57p0b4&"
            + "oauth_token_secret=PbKfYqSryyeKDWz4ebtY3o5ogNLG11WJuZBc9fQrQo&"
            + "screen_name=test&user_id=1";
    final Callback<OAuthResponse> callback = new Callback<OAuthResponse>() {
        @Override
        public void success(Result<OAuthResponse> result) {
            final OAuthResponse authResponse = result.data;
            assertEquals("7588892-kagSNqWge8gB1WwE3plnFsJHAZVfxWD7Vb57p0b4",
                    authResponse.authToken.token);
            assertEquals("PbKfYqSryyeKDWz4ebtY3o5ogNLG11WJuZBc9fQrQo",
                    authResponse.authToken.secret);
            assertEquals("test", authResponse.userName);
            assertEquals(1L, authResponse.userId);
        }

        @Override
        public void failure(TwitterException exception) {
            fail();
        }
    };
    setupCallbackWrapperTest(response, callback);
}
 

@Test
public void testRequestEmail_withSuccess() {
    final User user = new UserBuilder().setEmail(TEST_EMAIL).build();
    final Call<User> call = Calls.response(user);
    setupMockAccountService(call);

    authClient.requestEmail(mock(TwitterSession.class), new Callback<String>() {
        @Override
        public void success(Result<String> result) {
            assertEquals(TEST_EMAIL, result.data);
        }

        @Override
        public void failure(TwitterException exception) {
            fail("Expected Callback#success to be called");
        }
    });
}
 

@Test
public void testNext_succeedsWithFixedTweets() {
    final FixedTweetTimeline timeline = new FixedTweetTimeline(fixedTweets);
    timeline.next(ANY_ID, new Callback<TimelineResult<Tweet>>() {
        @Override
        public void success(Result<TimelineResult<Tweet>> result) {
            assertEquals(fixedTweets, result.data.items);
            assertEquals((Long) TestFixtures.TEST_PHOTO_TWEET.getId(),
                    result.data.timelineCursor.minPosition);
            assertEquals((Long) TestFixtures.TEST_TWEET.getId(),
                    result.data.timelineCursor.maxPosition);
            assertNull(result.response);
        }
        @Override
        public void failure(TwitterException exception) {
            fail("Expected FixedTweetTimeline next to always succeed.");
        }
    });
}
 

/**
 * loadTweets wraps TweetUtils.loadTweets to use a callback that ensures each view is given
 * a known id to simplify UI automation testing.
 */
private void loadTweets(final List<Long> tweetIds, final ViewGroup container,
                        final List<Integer> viewIds) {
    TweetUtils.loadTweets(tweetIds, new Callback<List<Tweet>>() {
        @Override
        public void success(Result<List<Tweet>> result) {
            final Context context = getActivity();
            if (context == null) return;
            for (int i = 0; i < result.data.size(); i++) {
                final BaseTweetView tv = new CompactTweetView(context, result.data.get(i),
                        R.style.tw__TweetDarkWithActionsStyle);
                tv.setOnActionCallback(actionCallback);
                tv.setId(viewIds.get(i));
                container.addView(tv);
            }
        }

        @Override
        public void failure(TwitterException exception) {
            Log.e(TAG, "loadTweets failure " + tweetIds, exception);
        }
    });
}
 

void uploadTweet(final TwitterSession session, final String text, final Uri imageUri) {
    if (imageUri != null) {
        uploadMedia(session, imageUri, new Callback<Media>() {
            @Override
            public void success(Result<Media> result) {
                uploadTweetWithMedia(session, text, result.data.mediaIdString);
            }

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

        });
    } else {
        uploadTweetWithMedia(session, text, null);
    }
}
 

@Test
public void testRequestGuestAuthToken_appAuthFailure() {

    service.api = new MockOAuth2Api() {
        @Override
        public Call<OAuth2Token> getAppAuthToken(@Header(OAuthConstants.HEADER_AUTHORIZATION) String auth,
                @Field(OAuthConstants.PARAM_GRANT_TYPE) String grantType) {
            return Calls.failure(new IOException());
        }
    };

    service.requestGuestAuthToken(new Callback<GuestAuthToken>() {
        @Override
        public void success(Result<GuestAuthToken> result) {
            fail();
        }

        @Override
        public void failure(TwitterException error) {
            assertNotNull(error);
        }
    });
}
 

private void setUpTwitterButton() {
    twitterButton = (TwitterLoginButton) findViewById(R.id.twitter_button);
    twitterButton.setCallback(new Callback<TwitterSession>() {
        @Override
        public void success(Result<TwitterSession> result) {
            SessionRecorder.recordSessionActive("Login: twitter account active", result.data);
            Answers.getInstance().logLogin(new LoginEvent().putMethod("Twitter").putSuccess(true));
            startThemeChooser();
        }

        @Override
        public void failure(TwitterException exception) {
            Answers.getInstance().logLogin(new LoginEvent().putMethod("Twitter").putSuccess(false));
            Toast.makeText(getApplicationContext(),
                    getResources().getString(R.string.toast_twitter_signin_fail),
                    Toast.LENGTH_SHORT).show();
            Crashlytics.logException(exception);
        }
    });
}
 

@Test
public void testRequestEmail_withFailure() {
    final IOException networkException = new IOException("Network failure");
    final Call<User> call = Calls.failure(networkException);
    setupMockAccountService(call);

    authClient.requestEmail(mock(TwitterSession.class), new Callback<String>() {
        @Override
        public void success(Result<String> result) {
            fail("Expected Callback#failure to be called");
        }

        @Override
        public void failure(TwitterException exception) {
            assertEquals(exception.getCause(), networkException);
        }
    });
}
 

public Observable<List<TimelineItem>> getTimelineItems() {
    return Observable.create(subscriber -> {
        Callback<List<Tweet>> callback = new Callback<List<Tweet>>() {
            @Override
            public void success(Result<List<Tweet>> result) {
                Log.i(TAG, "Got the tweets, buddy!");
                subscriber.onNext(TimelineConverter.fromTweets(result.data, DateTime.now()));
            }

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

        getStatusesService().homeTimeline(null, null, null, null, null, null, null).enqueue(callback);
    });
}
 

@Override
public void next(Long sinceId, Callback<TimelineResult<TestItem>> cb) {
    final List<TestItem> testItems = new ArrayList<>();
    TestItem.populateList(testItems, numItems);
    final TimelineResult<TestItem> timelineResult
            = new TimelineResult<>(new TimelineCursor(minPosition, maxPosition), testItems);
    cb.success(new Result<>(timelineResult, null));
}
 

@Test
public void testLoadPrevious() {
    delegate = new TimelineDelegate<>(mockTimeline);
    final Callback<TimelineResult<TestItem>> testCb = delegate.new PreviousCallback(
            delegate.timelineStateHolder);
    delegate.loadPrevious(TEST_MAX_POSITION, testCb);
    verify(mockTimeline).previous(TEST_MAX_POSITION, testCb);
}
 

@Test
public void testPrevious_createsCorrectRequest() {
    final SearchTimeline timeline = spy(new SearchTimeline(twitterCore, TEST_QUERY,
            TEST_GEOCODE, TEST_RESULT_TYPE, TEST_LANG, TEST_ITEMS_PER_REQUEST,
            TEST_UNTIL_DATE));
    timeline.previous(TEST_MAX_ID, mock(Callback.class));
    // intentionally decrementing the maxId which is passed through to the request
    verify(timeline).createSearchRequest(isNull(Long.class),
            eq(TEST_MAX_ID - 1));
}
 

@Test
public void testNewAccessTokenCallback_failure() {
    final Callback<OAuthResponse> callback = controller.newRequestAccessTokenCallback();
    final TwitterException mockException = mock(TwitterException.class);
    callback.failure(mockException);
    verifyOnCompleteWithError("Failed to get access token");
}
 

@Test
public void testNext_createsCorrectRequest() {
    final SearchTimeline timeline = spy(new SearchTimeline(twitterCore, TEST_QUERY,
            TEST_GEOCODE, TEST_RESULT_TYPE, TEST_LANG, TEST_ITEMS_PER_REQUEST,
            TEST_UNTIL_DATE));
    timeline.next(TEST_SINCE_ID, mock(Callback.class));
    verify(timeline).createSearchRequest(eq(TEST_SINCE_ID),
            isNull(Long.class));
}
 

@Test
public void testPrevious_createsCorrectRequest() {
    final CollectionTimeline timeline = spy(new CollectionTimeline(twitterCore,
            TEST_COLLECTION_ID, TEST_ITEMS_PER_REQUEST));
    timeline.next(TEST_MAX_POSITION, mock(Callback.class));
    verify(timeline).createCollectionRequest(eq(TEST_MAX_POSITION), isNull(Long.class));
}
 

TweetTimelineListAdapter(Context context, TimelineDelegate<Tweet> delegate, int styleResId,
                         Callback<Tweet> cb, TweetUi tweetUi) {
    super(context, delegate);
    this.styleResId = styleResId;
    this.actionCallback = new ReplaceTweetCallback(delegate, cb);
    this.tweetUi = tweetUi;
}
 

@Test
public void testLoadNext_respectsRequestInFlight() {
    delegate = new TimelineDelegate<>(mockTimeline);
    delegate.timelineStateHolder.startTimelineRequest();
    final Callback<TimelineResult<TestItem>> mockCallback = mock(Callback.class);
    delegate.loadNext(ANY_POSITION, mockCallback);
    final ArgumentCaptor<TwitterException> exceptionCaptor
            = ArgumentCaptor.forClass(TwitterException.class);
    verifyZeroInteractions(mockTimeline);
    verify(mockCallback).failure(exceptionCaptor.capture());
    assertEquals(exceptionCaptor.getValue().getMessage(), REQUIRED_REQUEST_IN_FLIGHT_ERROR);
}
 

/**
 * Loads a single Tweet by id.
 * @param tweetId Tweet id
 * @param cb callback
 */
public static void loadTweet(final long tweetId, final Callback<Tweet> cb) {
    TweetUi.getInstance().getTweetRepository().loadTweet(tweetId,
            new LoggingCallback<Tweet>(cb, Twitter.getLogger()) {
                @Override
                public void success(Result<Tweet> result) {
                    if (cb != null) {
                        cb.success(result);
                    }
                }
            });
}
 

@Test
public void testFailure_callsCb() {
    final Callback<Tweet> developerCallback = mock(Callback.class);
    final LoggingCallback<Tweet> cb
            = new TestLoggingCallback<>(developerCallback, mock(Logger.class));
    cb.failure(mock(TwitterException.class));
    verify(developerCallback).failure(any(TwitterException.class));
}
 

/**
 * Loads Tweets with id less than (older than) maxId.
 * @param maxId maximum id of the Tweets to load (exclusive).
 * @param cb callback.
 */
@Override
public void previous(Long maxId, Callback<TimelineResult<Tweet>> cb) {
    // user timeline api provides results which are inclusive, decrement the maxId to get
    // exclusive results
    createUserTimelineRequest(null, decrementMaxId(maxId)).enqueue(new TweetsCallback(cb));
}