Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.octo.android.robospice.request;
  
  import java.util.HashSet;
  import java.util.Map;
  import java.util.Set;
 
 
Delegate class of the com.octo.android.robospice.ContentService, easier to test than an Android android.app.Service. TODO make it possible to set the number of threads in the java.util.concurrent.ExecutorService

Author(s):
jva
 
 public class RequestProcessor {
 	// ============================================================================================
 	// CONSTANT
 	// ============================================================================================
 	private final static String LOG_CAT = "RequestProcessor";
 
 	// ============================================================================================
 	// ATTRIBUTES
 	// ============================================================================================
Thanks Olivier Croiser from Zenika for his excellent blog article.
 
 	private ExecutorService executorService = null;
 
 
 
 
 	private boolean failOnCacheError;
 
 
 	// ============================================================================================
 	// CONSTRUCTOR
 	// ============================================================================================
 
 	public RequestProcessor(Context contextICacheManager cacheManagerint threadCount) {
 		this. = context;
 		this. = cacheManager;
 		 = new Handler(Looper.getMainLooper());
 		initiateExecutorService(threadCount);
 	}
 
 	protected void initiateExecutorService(int threadCount) {
 		if (threadCount <= 0) {
 			throw new IllegalArgumentException("Thread count must be >= 1");
 		} else if (threadCount == 1) {
 		} else {
 			 = Executors.newFixedThreadPool(threadCountnew ThreadFactory() {
 
 				public Thread newThread(Runnable r) {
 					return new Thread(r);
 				}
 			});
 		}
 	}
 
 	// ============================================================================================
 	// PUBLIC
 	// ============================================================================================
	public void addRequest(final CachedContentRequest<?> requestSet<RequestListener<?>> listRequestListener) {
		Log.d("Adding request to queue : " + request);
		if (listRequestListener != null) {
			Set<RequestListener<?>> listRequestListenerForThisRequest = .get(request);
			if (listRequestListenerForThisRequest == null) {
				listRequestListenerForThisRequest = new HashSet<RequestListener<?>>();
				this..put(requestlistRequestListenerForThisRequest);
			}
			listRequestListenerForThisRequest.addAll(listRequestListener);
		}
		Future<?> future = .submit(new Runnable() {
			public void run() {
			}
		});
		request.setFuture(future);
	}
	@SuppressWarnings({ "rawtypes""unchecked" })
	protected <T> void processRequest(CachedContentRequest<T> request) {
		Log.d("Processing request : " + request);
result = null;
		Set<RequestListener<?>> requestListeners = .get(request);
		if (request.isCancelled()) {
			Log.d("Not processing request : " + request + " as it is cancelled. ");
			.post(new ResultRunnable(requestListenersnew RequestCancelledException("Request has been cancelled explicitely.")));
			return;
		}
		if (request.getRequestCacheKey() != null) {
			// First, search data in cache
			try {
				Log.d("Loading request from cache : " + request);
				result = loadDataFromCache(request.getResultType(), request.getRequestCacheKey(), request.getCacheDuration());
catch (CacheLoadingException e) {
				Log.d(getClass().getName(), "Cache file could not be read."e);
					.post(new ResultRunnable(requestListenerse));
					return;
				}
			}
		}
		if (request.isCancelled()) {
			Log.d("Not calling network request : " + request + " as it is cancelled. ");
			.post(new ResultRunnable(requestListenersnew RequestCancelledException("Request has been cancelled explicitely.")));
			return;
		}
		if (result == null && !request.isCancelled()) {
			// if file is not found or the date is a day after or cache
			// disabled, call the web service
			Log.d("Cache content not available or expired or disabled");
				Log.e("Network is down.");
				.post(new ResultRunnable(requestListenersnew NoNetworkException()));
				return;
else {
				// Nothing found in cache (or cache expired), load from network
				try {
					Log.d("Calling netwok request.");
					result = request.loadDataFromNetwork();
					Log.d("Network request call ended.");
					if (result == null) {
						Log.d("Unable to get web service result : " + request.getResultType());
						.post(new ResultRunnable(requestListeners, (T) null));
						return;
					}
catch (Exception e) {
					if (request.isCancelled()) {
						Log.d("Request received error and is cancelled.");
								"Request has been cancelled explicitely."e)));
						return;
					}
					Log.e("An exception occured during request network execution :" + e.getMessage(), e);
							"Exception occured during invocation of web service."e)));
					return;
				}
				if (request.isCancelled()) {
					Log.d("Request did not receive error but is cancelled.");
					.post(new ResultRunnable(requestListeners,
							new RequestCancelledException("Request has been cancelled explicitely.")));
					return;
				}
				if (request.getRequestCacheKey() != null) {
					// request worked and result is not null
					try {
						Log.d("Start caching content...");
						result = saveDataToCacheAndReturnData(resultrequest.getRequestCacheKey());
						.post(new ResultRunnable(requestListenersresult));
						return;
catch (CacheSavingException e) {
						Log.d("An exception occured during service execution :" + e.getMessage(), e);
							.post(new ResultRunnable(requestListenerse));
							return;
						}
					}
				}
			}
		}
		// we reached that point so write in cache didn't work but network
		// worked.
		.post(new ResultRunnable(requestListenersresult));
	}

Disable request listeners notifications for a specific request.
All listeners associated to this request won't be called when request will finish.
Should be called in android.app.Activity.onPause()

Parameters:
request Request on which you want to disable listeners
listRequestListener the collection of listeners associated to request not to be notified
	public void dontNotifyRequestListenersForRequest(ContentRequest<?> requestCollection<RequestListener<?>> listRequestListener) {
		for (CachedContentRequest<?> cachedContentRequest : .keySet()) {
			if (cachedContentRequest.getContentRequest().equals(request)) {
				Set<RequestListener<?>> setRequestListener = .get(cachedContentRequest);
				if (setRequestListener != null && listRequestListener != null) {
					setRequestListener.removeAll(listRequestListener);
				}
				break;
			}
		}
	}

Returns:
true if network is available (at least one way to connect to network is connected or connecting).
	public boolean isNetworkAvailable(Context context) {
		NetworkInfo[] allNetworkInfos = connectivityManager.getAllNetworkInfo();
		for (NetworkInfo networkInfo : allNetworkInfos) {
			if (networkInfo.getState() == .. || networkInfo.getState() == ..) {
				return true;
			}
		}
		return false;
	}
	public boolean removeDataFromCache(Class<?> clazzObject cacheKey) {
		return .removeDataFromCache(clazzcacheKey);
	}
	public void removeAllDataFromCache(Class<?> clazz) {
	}
	public void removeAllDataFromCache() {
	}
	public boolean isFailOnCacheError() {
	}
	public void setFailOnCacheError(boolean failOnCacheError) {
		this. = failOnCacheError;
	}
	// ============================================================================================
	// PRIVATE
	// ============================================================================================
	private <T> T loadDataFromCache(Class<T> clazzObject cacheKeylong maxTimeInCacheBeforeExpirythrows CacheLoadingException {
		return .loadDataFromCache(clazzcacheKeymaxTimeInCacheBeforeExpiry);
	}
	private <T> T saveDataToCacheAndReturnData(T dataObject cacheKeythrows CacheSavingException {
	}
	private class ResultRunnable<T> implements Runnable {
		private T result;
		public ResultRunnable(Set<RequestListener<T>> listeners, T result) {
			this. = result;
			this. = listeners;
		}
		public ResultRunnable(Set<RequestListener<T>> listenersContentManagerException contentManagerException) {
			this. = listeners;
			this. = contentManagerException;
		}
		public void run() {
			if ( == null) {
				return;
			}
			String resultMsg =  == null ? "success" : "failure";
			Log.v("Notifying " + .size() + " listeners of request " + resultMsg);
			for (RequestListener<T> listener : ) {
				if ( == null) {
else {
				}
			}
		}
	}
	public String toString() {
		StringBuilder stringBuilder = new StringBuilder();
		stringBuilder.append('[');
		stringBuilder.append(getClass().getName());
		stringBuilder.append(" : ");
		stringBuilder.append(" request count= ");
		stringBuilder.append(", listeners per requests = [");
			stringBuilder.append(entry.getKey().getClass().getName());
			stringBuilder.append(":");
			stringBuilder.append(entry.getKey());
			stringBuilder.append(" --> ");
			if (entry.getValue() == null) {
				stringBuilder.append(entry.getValue());
else {
				stringBuilder.append(entry.getValue().size());
			}
		}
		stringBuilder.append(']');
		stringBuilder.append(']');
		return stringBuilder.toString();
	}
	public void addContentServiceListener(ContentServiceListener contentServiceListener) {
		this..add(contentServiceListener);
	}
	public void removeContentServiceListener(ContentServiceListener contentServiceListener) {
		this..add(contentServiceListener);
	}
	protected void fireCacheContentRequestProcessed(CachedContentRequest<?> cachedContentRequest) {
		for (ContentServiceListener contentServiceListener : ) {
			contentServiceListener.onRequestProcessed(cachedContentRequest);
		}
	}
New to GrepCode? Check out our FAQ X