Java Session类代码示例

import com.twitter.sdk.android.core.Session; //导入依赖的package包/类
@Test
public void testGetApiClient_withDifferentSession() {
    final DigitsSession session2 = DigitsSession.create(TestConstants.LOGGED_OUT_USER, "");
    final MockDigitsApiClientManager client =
            new MockDigitsApiClientManager(twitterCore, executorService, mockSessionManager,
                    activeClient, interceptor);
    // Want to ensure it returns different client
    final DigitsApiClient firstClient = digitsClient.getApiClient();
    final Session active = firstClient.getSession();
    assertEquals(active, mockSessionManager.getActiveSession());
    assertEquals(activeClient, firstClient);

    mockSessionManager = mock(SessionManager.class);
    when(mockSessionManager.getActiveSession()).thenReturn(session2);
    activeClient = mock(DigitsApiClient.class);
    when(activeClient.getSession()).thenReturn(session2);
    assertNotSame(activeClient, firstClient);

    final DigitsApiClient newClient = digitsClient.getApiClient();
    final Session newActive = newClient.getSession();
    assertEquals(newActive, mockSessionManager.getActiveSession());
}
 

import com.twitter.sdk.android.core.Session; //导入依赖的package包/类
/**
 * Constructor.
 *
 * @param context the context
 * @param executor scheduled executor service for executing scribe requests on background thread
 * @param scribeConfig the scribe configuration
 * @param transform the scribe event transform for serializing and deserializing scribe events
 * flush of all queued events as long as a network connection is available.
 * @param authConfig the auth configuration
 * @param sessionManager the session manager
 * @param idManager the id manager used to provide the device id
 */
public ScribeClient(Context context, ScheduledExecutorService executor,
        ScribeConfig scribeConfig, ScribeEvent.Transform transform,
        TwitterAuthConfig authConfig,
        SessionManager<? extends Session<TwitterAuthToken>> sessionManager,
        GuestSessionProvider guestSessionProvider, IdManager idManager) {
    this.context = context;
    this.executor = executor;
    this.scribeConfig = scribeConfig;
    this.transform = transform;
    this.authConfig = authConfig;
    this.sessionManager = sessionManager;
    this.guestSessionProvider = guestSessionProvider;
    this.idManager = idManager;

    // Set initial capacity to 2 to handle one logged in user and one logged out user.
    scribeHandlers = new ConcurrentHashMap<>(2);
}
 

import com.twitter.sdk.android.core.Session; //导入依赖的package包/类
@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);
}
 

import com.twitter.sdk.android.core.Session; //导入依赖的package包/类
public FollowersInfoViewModel(@NonNull DataListener dataListener, @NonNull Context context,
                              Session session, User user) {
    this.dataListener = dataListener;
    this.context = context;
    this.session = session;
    this.user = user;

    activityFollowersInfoRecyclerView = new ObservableInt(View.GONE);

    initializeViews();
    fetchTweetsList();
}
 

import com.twitter.sdk.android.core.Session; //导入依赖的package包/类
TwitterApiClient(TwitterAuthConfig authConfig,
                 Session session,
                 TwitterApi twitterApi,
                 SSLSocketFactory sslSocketFactory, ExecutorService executorService) {

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

    this.services = new ConcurrentHashMap<>();

    final Gson gson = new GsonBuilder()
            .registerTypeAdapterFactory(new SafeListAdapter())
            .registerTypeAdapterFactory(new SafeMapAdapter())
            // Using RealmUserJsonSerializerDeserializer class for Users List
            .registerTypeAdapter(new TypeToken<RealmList<User>>() {
                    }.getType(),
                    new RealmUserJsonSerializerDeserializer())
            // Using RealmTweetsJsonSerializerDeserializer class for Tweets List
            .registerTypeAdapter(new TypeToken<RealmList<Tweets>>() {
                    }.getType(),
                    new RealmTweetsJsonSerializerDeserializer())
            .registerTypeAdapter(BindingValues.class, new BindingValuesAdapter())
            .create();

    apiAdapter = new RestAdapter.Builder()
            .setClient(new AuthenticatedClient(authConfig, session, sslSocketFactory))
            .setEndpoint(twitterApi.getBaseHostUrl())
            .setConverter(new GsonConverter(gson))
            .setExecutors(executorService, new MainThreadExecutor())
            .build();

    uploadAdapter = new RestAdapter.Builder()
            .setClient(new AuthenticatedClient(authConfig, session, sslSocketFactory))
            .setEndpoint(UPLOAD_ENDPOINT)
            .setConverter(new GsonConverter(gson))
            .setExecutors(executorService, new MainThreadExecutor())
            .build();
}
 

import com.twitter.sdk.android.core.Session; //导入依赖的package包/类
DigitsGuestSessionProvider(SessionManager<DigitsSession> defaultSessionManager,
        List<SessionManager<? extends Session>> sessionManagers, OAuth2Service oAuth2Service) {
    super(sessionManagers);

    this.defaultSessionManager = defaultSessionManager;
    this.oAuth2Service = oAuth2Service;
}
 

import com.twitter.sdk.android.core.Session; //导入依赖的package包/类
@Override
public void success(Result<OAuth2Token> result) {
    final DigitsSession session = new DigitsSession(result.data);
    // set session in manager, manager makes session active if there is no active session
    sessionManager.setSession(session.getId(), session);
    if (callback != null) {
        callback.success(new Result<Session>(session, result.response));
    }
}
 

import com.twitter.sdk.android.core.Session; //导入依赖的package包/类
protected synchronized boolean addClientRequest(final Callback<ApiInterface> callback) {
    return addRequest(new Callback<Session>() {
        @Override
        public void success(Result<Session> result) {
            callback.success(new Result<>(
                    apiClientManager.getApiClient().getService(), null));
        }

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

import com.twitter.sdk.android.core.Session; //导入依赖的package包/类
@Override
public void verifySession(final Session session) {
    if (session instanceof DigitsSession && !((DigitsSession) session).isLoggedOutUser()) {
        final ApiInterface service = getAccountService();
        service.verifyAccount(verificationCallback);
    }
}
 

import com.twitter.sdk.android.core.Session; //导入依赖的package包/类
private synchronized void createTwitterScribeClient(SessionManager sessionManager,
                                                    IdManager idManager) {
    if (twitterScribeClient == null) {
        final List<SessionManager<? extends Session>> sessionManagers = new ArrayList<>();
        sessionManagers.add(sessionManager);

        twitterScribeClient = new DefaultScribeClient(this, DigitsUserAgent.create().toString(),
                sessionManagers, idManager);
    }
}
 

import com.twitter.sdk.android.core.Session; //导入依赖的package包/类
protected DigitsAuthRequestQueue createAuthRequestQueue(SessionManager sessionManager) {
    final List<SessionManager<? extends Session>> sessionManagers = new ArrayList<>(1);
    sessionManagers.add(sessionManager);
    final DigitsGuestSessionProvider sessionProvider =
            new DigitsGuestSessionProvider(sessionManager, sessionManagers);
    return new DigitsAuthRequestQueue(apiClientManager, sessionProvider);
}
 

import com.twitter.sdk.android.core.Session; //导入依赖的package包/类
@Test
public void testVerifySession_nonDigitsSession() throws Exception {
    final Session session = mock(Session.class);
    doReturn(accountService).when(verifier).getAccountService();
    verifier.verifySession(session);
    verifyZeroInteractions(accountService);
    verifyZeroInteractions(verificationCallback);
}
 

import com.twitter.sdk.android.core.Session; //导入依赖的package包/类
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();
}
 

import com.twitter.sdk.android.core.Session; //导入依赖的package包/类
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();
}
 

import com.twitter.sdk.android.core.Session; //导入依赖的package包/类
static OkHttpClient.Builder addSessionAuth(OkHttpClient.Builder builder,
                                           Session<? extends TwitterAuthToken> session,
                                           TwitterAuthConfig authConfig) {
    return builder
            .certificatePinner(getCertificatePinner())
            .addInterceptor(new OAuth1aInterceptor(session, authConfig));
}