com.android.volley.toolbox.HttpStack Java Examples

private RequestQueue newRequestQueue(Context context) {
    // define cache folder
    File rootCache = context.getExternalCacheDir();
    if (rootCache == null) {
        rootCache = context.getCacheDir();
    }

    File cacheDir = new File(rootCache, DEFAULT_CACHE_DIR);
    cacheDir.mkdirs();

    HttpStack stack = new HurlStack();
    Network network = new BasicNetwork(stack);
    DiskBasedCache diskBasedCache = new DiskBasedCache(cacheDir, DEFAULT_DISK_USAGE_BYTES);
    RequestQueue queue = new RequestQueue(diskBasedCache, network);
    queue.start();

    return queue;
}
 

public FileMockNetwork(Context context, Config config) {
    mContext = context;
    mConfig = config;

    // configure the real network for non mocked requests
    if (config.mRealNetwork == null) {
        HttpStack httpStack = (config.mRealNetworkHttpStack == null) ? ConfigUtils.getDefaultHttpStack(mContext) : config.mRealNetworkHttpStack;
        config.mRealNetwork = ConfigUtils.getDefaultNetwork(httpStack);
    }

    if (!mConfig.mBasePath.equals("") && !mConfig.mBasePath.endsWith("/")) {
        mConfig.mBasePath += "/";
    }
}
 

@Test
public void testWaspHttpStackCustom() throws Exception {

  class MyHttpStack implements WaspHttpStack {

    @Override
    public HttpStack getHttpStack() {
      return new OkHttpStack(new OkHttpClient());
    }

    @Override
    public void setHostnameVerifier(HostnameVerifier hostnameVerifier) {

    }

    @Override
    public void setSslSocketFactory(SSLSocketFactory sslSocketFactory) {

    }

    @Override
    public void setCookieHandler(CookieHandler cookieHandler) {

    }
  }

  Wasp.Builder builder = new Wasp.Builder(context)
      .setWaspHttpStack(new MyHttpStack())
      .setEndpoint("http");
  builder.build();

  //default should be NONE
  assertThat(builder.getWaspHttpStack()).isInstanceOf(MyHttpStack.class);
}
 

public static HttpStack createStack() {
    if(hasOkHttp()) {
        OkHttpClient okHttpClient = new OkHttpClient();
        VolleyLog.d("OkHttp found, using okhttp for http stack");
        return new OkHttpStack(okHttpClient);
    }
    else if (useHttpClient()){
        VolleyLog.d("Android version is older than Gingerbread (API 9), using HttpClient");
        return new HttpClientStack(AndroidHttpClient.newInstance(USER_AGENT));
    }
    else {
        VolleyLog.d("Using Default HttpUrlConnection");
        return new HurlStack();
    }
}
 

public static RequestQueue newRequestQueue(Context context, HttpStack stack, int threadPoolSize) {
    return newRequestQueue(context, stack, -1, threadPoolSize);
}
 

/**
* @param httpStack The HTTP stack that requests are performed with.
*/
  public JacksonNetwork(HttpStack httpStack) {
this(httpStack, DEFAULT_POOL_SIZE);
  }
 

public static Network getDefaultNetwork(HttpStack httpStack) {
    return new BasicNetwork(httpStack);
}
 

public HttpStack getHttpStack() {
    return mHttpStack;
}
 

public Config realNetworkHttpStack(HttpStack httpStack) {
    mRealNetworkHttpStack = httpStack;
    return this;
}
 

public VolleyBall(Context aContext, HttpStack aStack) {
    mContext = aContext.getApplicationContext();
    mStack = aStack;
    mVolley = Volley.newRequestQueue(mContext, aStack);
}
 

@Override
public Network onCreateNetwork(HttpStack httpStack) {
    return new PlayNetwork(getContext());
}
 

public HttpStack onCreateHttpStack() {
    return HttpStackSelector.createStack();
}
 

public Network onCreateNetwork(HttpStack httpStack) {
    return new BasicNetwork(httpStack);
}
 

/**
 * @param httpStack HTTP stack to be used
 * @param pool a buffer pool that improves GC performance in copy operations
 */
public RVNetwork(HttpStack httpStack, ByteArrayPool pool) {
    mHttpStack = httpStack;
    mPool = pool;
}
 

/**
 * @param httpStack HTTP stack to be used
 */
public RVNetwork(HttpStack httpStack) {
    // If a pool isn't passed in, then build a small default pool that will give us a lot of
    // benefit and not use too much memory.
    this(httpStack, new ByteArrayPool(DEFAULT_POOL_SIZE));
}
 

/**
 * @param httpStack HTTP stack to be used
 */
public StreamBasedNetwork(HttpStack httpStack) {
    super(httpStack);
}
 

public static RequestQueue newRequestQueue(Context context, HttpStack stack, int threadPoolSize, boolean isStreamBasedResponse) {
    return newRequestQueue(context, stack, -1, threadPoolSize, isStreamBasedResponse);
}
 

public static RequestQueue newRequestQueue(Context context, HttpStack stack, int maxDiskCacheBytes, int threadPoolSize) {
    return newRequestQueue(context, stack, maxDiskCacheBytes, threadPoolSize, false);
}
 

/**
 * @param httpStack The HTTP stack that requests are performed with.
 * @param poolSize The size of the pool buffer used for cached requests. NOTE: caching
 *                 requests will have a significant adverse affect on parsing speed!
 */
public JacksonNetwork(HttpStack httpStack, int poolSize) {
	mHttpStack = httpStack;
	mPool = new ByteArrayPool(poolSize);
}
 

/**
 * Creates a default instance of the worker pool and calls {@link RequestQueue#start()} on it.
 *
 * @param context A {@link Context} to use for creating the cache dir.
 * @param stack An {@link com.android.volley.toolbox.HttpStack} to use for handling network calls
 * @return A started {@link RequestQueue} instance.
 */
public static RequestQueue newRequestQueue(Context context, HttpStack stack) {
	RequestQueue queue = new RequestQueue(new DiskBasedCache(new File(context.getCacheDir(), "volley")), new JacksonNetwork(stack));
	queue.start();
	return queue;
}