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

@Before
public void setUp() throws Exception {

    mockSessionManager = mock(SessionManager.class);
    mockSystemCurrentTimeProvider = mock(SystemCurrentTimeProvider.class);
    mockExecutorService = mock(ExecutorService.class);
    mockMonitorState = mock(SessionMonitor.MonitorState.class);
    mockSessionVerifier = mock(SessionVerifier.class);
    sessionMonitor = new SessionMonitor<>(mockSessionManager, mockSystemCurrentTimeProvider,
            mockExecutorService, mockMonitorState, mockSessionVerifier);
    monitorState = new SessionMonitor.MonitorState();
    final Session testSession = mock(Session.class);
    when(testSession.getId()).thenReturn(1L);
    sessionMap = new HashMap<>();
    sessionMap.put(1L, testSession);

    when(mockSessionManager.getSessionMap()).thenReturn(sessionMap);
    when(mockSessionManager.getActiveSession()).thenReturn(testSession);
}
 

public static OkHttpClient getOkHttpClient(Session<? extends TwitterAuthToken> session,
        TwitterAuthConfig authConfig) {
    if (session == null) {
        throw new IllegalArgumentException("Session must not be null.");
    }

    return addSessionAuth(new OkHttpClient.Builder(), session, authConfig).build();
}
 

public static OkHttpClient getCustomOkHttpClient(
        OkHttpClient httpClient,
        Session<? extends TwitterAuthToken> session,
        TwitterAuthConfig authConfig) {
    if (session == null) {
        throw new IllegalArgumentException("Session must not be null.");
    }

    if (httpClient == null) {
        throw new IllegalArgumentException("HttpClient must not be null.");
    }

    return addSessionAuth(httpClient.newBuilder(), session, authConfig)
            .build();
}
 

static OkHttpClient.Builder addSessionAuth(OkHttpClient.Builder builder,
                                           Session<? extends TwitterAuthToken> session,
                                           TwitterAuthConfig authConfig) {
    return builder
            .certificatePinner(getCertificatePinner())
            .addInterceptor(new OAuth1aInterceptor(session, authConfig));
}
 

/**
 * triggerVerificationIfNecessary checks if there are any sessions to verify and if enough time
 * has passed in order to run another verification. If it determines it can verify, it submits a
 * runnable that does the verification in a background thread.
 */
public void triggerVerificationIfNecessary() {
    final Session session = sessionManager.getActiveSession();
    final long currentTime = time.getCurrentTimeMillis();
    final boolean startVerification = session != null &&
            monitorState.beginVerification(currentTime);
    if (startVerification) {
        executorService.submit(this::verifyAll);
    }
}
 

@Test
public void testVerifySession_callsAccountService() {
    when(mockMonitorState.beginVerification(anyLong())).thenReturn(Boolean.TRUE);
    sessionMonitor.triggerVerificationIfNecessary();
    final ArgumentCaptor<Runnable> runnableArgumentCaptor = ArgumentCaptor.forClass(Runnable
            .class);
    verify(mockExecutorService).submit(runnableArgumentCaptor.capture());
    final Runnable tasks = runnableArgumentCaptor.getValue();
    tasks.run();
    verify(mockSessionVerifier).verifySession(any(Session.class));
}
 

public static Session recordInitialSessionState(Session twitterSession,
                                                Session digitsSession) {
    if (twitterSession != null) {
        recordSessionActive("Splash: user with active Twitter session", twitterSession);
        return twitterSession;
    } else if (digitsSession != null) {
        recordSessionActive("Splash: user with active Digits session", digitsSession);
        return digitsSession;
    } else {
        recordSessionInactive("Splash: anonymous user");
        return null;
    }
}
 

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

    final Session activeSession = SessionRecorder.recordInitialSessionState(
            Twitter.getSessionManager().getActiveSession(),
            Digits.getSessionManager().getActiveSession()
    );

    if (activeSession != null) {
        startThemeActivity();
    } else {
        startLoginActivity();
    }
}
 

public RxTwitterApiClient(Session session) {
    super(session);
}
 

static void mockClients(ConcurrentHashMap<Session, TwitterApiClient> clients,
                               TwitterApiClient apiClient) {
    when(clients.get(anyObject())).thenReturn(apiClient);
    when(clients.contains(anyObject())).thenReturn(true);
}
 

public OAuth1aInterceptor(Session<? extends TwitterAuthToken> session,
        TwitterAuthConfig authConfig) {
    this.session = session;
    this.authConfig = authConfig;
}
 

@Test
public void testVerifyAll_verifiesAllSessions() {
    sessionMap.put(2L, mock(Session.class));
    sessionMonitor.verifyAll();
    verify(mockSessionVerifier, times(2)).verifySession(any(Session.class));
}
 

public static void recordSessionActive(String message, Session session) {
    recordSessionActive(message, String.valueOf(session.getId()));
}