public String GetKnnAsString(String featureVector) {
// System.err.println(featureVector);
// System.err.println(trainingVectors.size());
FeatureVector fv = new FeatureVector(featureVector, 32);
PriorityBlockingQueue<CategoryDistances> pbq = new PriorityBlockingQueue<>();
ExecutorService pool = Executors.newFixedThreadPool(NumWorkers);
String outp = "";
for (FeatureVector elem : trainingVectors) {
pool.execute(new EuclideanWorker(elem, fv, pbq));
}
pool.shutdown();
while (!pool.isTerminated()) {;
}
for (int i = 0; i < K; i++) {
CategoryDistances cd = pbq.poll();
if (cd == null) {
break;
}
outp += cd.toString() + VectorDelim;
}
// System.out.println(outp);
return outp.substring(0, outp.length() - 1);
}
public static void addImage(BufferedImage img, UtmPose pose) {
if (imagesDir != null) {
try {
File outputfile =
new File(
imagesDir.getAbsolutePath() + File.separator + "BoatImg" + (new Date()) + ".png");
System.out.println("Writing to " + outputfile + " " + pose);
ImageIO.write(img, "png", outputfile);
} catch (IOException e) {
System.out.println("Failed to write image to file: " + e);
}
} else {
System.out.println("Do not know where to save images");
}
if (queue.size() > 100) {
int v = rateS.getValue();
int nv = Math.min(100, Math.max(v, (rateS.getValue() / 10)));
if (v != nv) {
rateS.setValue(nv);
}
}
if (queue.size() < 1000) {
queue.offer(new BufferedImageWithPose(img, pose));
queueP.setValue(Math.min(100, queue.size()));
} else {
System.out.println("No longer queuing images, queue is full");
}
}
private DataNodeIdentifier pickHeaviestLoad(DataNodeIdentifier otherNode) {
DataNodeIdentifier replacementNode = null;
PriorityBlockingQueue<DataNodeStatusPair> invertedStatusQueue =
new PriorityBlockingQueue<DataNodeStatusPair>(
datanodeStatuses.size(),
new Comparator<DataNodeStatusPair>() {
public int compare(DataNodeStatusPair a, DataNodeStatusPair b) {
return -1 * a.compareTo(b);
}
});
for (DataNodeStatusPair each : datanodeStatuses) {
invertedStatusQueue.put(each);
}
while (replacementNode == null) {
DataNodeStatusPair next = invertedStatusQueue.poll();
DataNodeIdentifier nextId = next.getIdentifier();
if (!nextId.equals(otherNode)) {
replacementNode = nextId;
}
}
return replacementNode;
}
static void b2487514Test() {
PriorityBlockingQueue q = new PriorityBlockingQueue(10);
int catchCount = 0;
q.offer(new Integer(0));
/*
* Warm up the code cache to have toArray() compiled. The key here is
* to pass a compatible type so that there are no exceptions when
* executing the method body (ie the APUT_OBJECT bytecode).
*/
for (int i = 0; i < 1000; i++) {
Integer[] ints = (Integer[]) q.toArray(new Integer[5]);
}
/* Now pass an incompatible type which is guaranteed to throw */
for (int i = 0; i < 1000; i++) {
try {
Object[] obj = q.toArray(new String[5]);
} catch (ArrayStoreException success) {
catchCount++;
}
}
if (catchCount == 1000) {
System.out.println("b2487514 passes");
} else {
System.out.println("b2487514 fails: catchCount is " + catchCount + " (expecting 1000)");
}
}
@Override
public Mission getMission(Sergeant s) {
if (this.isEmpty()) return null;
PriorityBlockingQueue<Mission> relevantQueue;
Vector<Mission> temp = new Vector<Mission>();
if (s.getPriority().equals(Sergeant.SHORTEST)) relevantQueue = this.minLength;
else if (s.getPriority().equals(Sergeant.LONGEST)) relevantQueue = this.maxLength;
else if (s.getPriority().equals(Sergeant.MINITEMS)) relevantQueue = this.minItems;
else relevantQueue = this.maxItems;
while (!relevantQueue.isEmpty()) {
Mission candidate = relevantQueue.poll();
temp.add(candidate);
WarSim.LOG.fine("Testing Mission " + candidate.getName() + "(" + candidate.getSkill() + ")");
if (s.getSkills().contains(candidate.getSkill())) {
for (Mission tm : temp) relevantQueue.put(tm);
return candidate;
} else
WarSim.LOG.fine(
"The sergeant " + s.getName() + " can't execute mission " + candidate.getName());
}
for (Mission tm : temp) relevantQueue.put(tm);
return null;
}
public static BufferedImage getImage() {
try {
BufferedImage b = queue.take().img;
queueP.setValue(Math.min(100, queue.size()));
return b;
} catch (InterruptedException e) {
}
return null;
}
public void run() {
while (stillAlive.get()) {
synchronized (this) {
try {
ScheduledJob job = schedule.peek();
if (job == null) {
// If null, wake up every minute or so to see if there's something to do.
// Most likely there will not be.
try {
this.wait(TIMEOUT_MS);
} catch (InterruptedException e) {
// interruption should occur when items are added or removed from the queue.
}
} else {
// We've passed the job execution time, so we will run.
if (!job.getScheduledExecution().isAfterNow()) {
// Run job. The invocation of jobs should be quick.
ScheduledJob runningJob = schedule.poll();
logger.info("Scheduler attempting to run " + runningJob.getId());
// Execute the job here
try {
executionManager.execute(runningJob.getId(), runningJob.isDependencyIgnored());
} catch (JobExecutionException e) {
logger.info("Could not run job. " + e.getMessage());
}
// Immediately reschedule if it's possible. Let the execution manager
// handle any duplicate runs.
if (runningJob.updateTime()) {
schedule.add(runningJob);
saveSchedule();
} else {
// No need to keep it in the schedule.
removeScheduledJob(runningJob);
}
} else {
// wait until job run
long millisWait =
Math.max(
0, job.getScheduledExecution().getMillis() - (new DateTime()).getMillis());
try {
this.wait(Math.min(millisWait, TIMEOUT_MS));
} catch (InterruptedException e) {
// interruption should occur when items are added or removed from the queue.
}
}
}
} catch (Exception e) {
logger.error("Unexpected exception has been thrown in scheduler", e);
} catch (Throwable e) {
logger.error("Unexpected throwable has been thrown in scheduler", e);
}
}
}
}
public void compute() {
/* Tant qu'il reste des points dans le tas */
while (!q.isEmpty()) {
/* Extraire le point le plus proche de l'arrivée */
try {
current = q.take();
// update();
/* appelle les obs */
/* Trouver les voisins & MAJ -> dans une autre méthode */
trouverVoisinEtMaj(current);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void putEvent(GameEvent gameEvent) {
try {
queue.put(gameEvent);
} catch (Exception e) {
logger.error("<putEvent> but catch exception " + e.toString(), e);
}
}
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
Event event = new Event(id, i);
queue.add(event);
}
}
public static void updateWorkQueue(ArrayList<String> newTaskUrl) {
for (ImageLoadTask task : mHashMap.values()) {
if (!newTaskUrl.contains(task.mImageUrl)) {
mWorkQueue.remove(task);
mHashMap.remove(task.mImageUrl);
}
}
}
/**
* Adds a Request to the dispatch queue.
*
* @param request The request to service
* @return The passed-in request
*/
public Request add(Request request) {
// Tag the request as belonging to this queue and add it to the set of current requests.
request.setRequestQueue(this);
// Rewrite the url, in case of GET requests
if (mUrlRewriter != null) {
request.setUrl(mUrlRewriter.rewriteUrl(request));
}
synchronized (mCurrentRequests) {
mCurrentRequests.add(request);
}
// Process requests in the order they are added.
request.setSequence(getSequenceNumber());
request.addMarker("add-to-queue");
// If the request is uncacheable, skip the cache queue and go straight to the network.
if (!request.shouldCache()) {
mNetworkQueue.add(request);
return request;
}
// Insert request into stage if there's already a request with the same cache key in flight.
synchronized (mWaitingRequests) {
String cacheKey = request.getCacheKey();
if (mWaitingRequests.containsKey(cacheKey)) {
// There is already a request in flight. Queue up.
Queue<Request> stagedRequests = mWaitingRequests.get(cacheKey);
if (stagedRequests == null) {
stagedRequests = new LinkedList<Request>();
}
stagedRequests.add(request);
mWaitingRequests.put(cacheKey, stagedRequests);
if (VolleyLog.sDebug) {
VolleyLog.v("Request for cacheKey=%s is in flight, putting on hold.", cacheKey);
}
} else {
// Insert 'null' queue for this cacheKey, indicating there is now a request in
// flight.
mWaitingRequests.put(cacheKey, null);
mCacheQueue.add(request);
}
return request;
}
}
synchronized void completeInitWork(InitWork iw) {
m_jobs.remove(iw.getClass());
for (Class<? extends InitWork> cls : iw.m_blockees) {
InitWork blockee = m_jobs.get(cls);
boolean success = blockee.m_blockers.remove(iw.getClass());
assert (success);
if (blockee.m_blockers.size() == 0) {
m_readyJobs.add(blockee);
}
}
if (m_jobs.size() == 0) {
// tell all the threads to stop
for (int i = 0; i < m_threadCount; ++i) {
m_readyJobs.add(new COMPLETION_WORK());
}
}
}
public static void submitTask(String fileUrl, ImageLoadTask task) {
Log.e(TAG, "execute a ImageLoadTask ! sWorkQueue.size() = " + mWorkQueue.size());
if (mHashMap.get(fileUrl) == null) {
mHashMap.put(fileUrl, task);
mExecutor.execute(task);
} else {
Log.e(TAG, "there is already a task running !");
}
}
@Override
public synchronized String toString() {
return Objects.toStringHelper(this)
.add("runnerThreads", runnerThreads)
.add("allSplits", allSplits.size())
.add("pendingSplits", pendingSplits.size())
.add("runningSplits", runningSplits.size())
.add("blockedSplits", blockedSplits.size())
.toString();
}
/** Removes the first task in the taskQueue with the taskKey */
public boolean removeTaskByKey(String taskKey) {
Iterator<MeasurementTask> it = taskQueue.iterator();
while (it.hasNext()) {
MeasurementTask task = it.next();
if (task.getDescription().key.equals(taskKey)) {
it.remove();
return true;
}
}
return false;
}
private DataNodeIdentifier pickReplacement(
SegmentGroup affectedGroup, DataNodeIdentifier oldNode) {
DataNodeIdentifier replacementNode = null;
List<DataNodeStatusPair> removedPairs = new ArrayList<DataNodeStatusPair>();
while (replacementNode == null) {
DataNodeStatusPair next = datanodeStatuses.poll();
removedPairs.add(next);
DataNodeIdentifier nextId = next.getIdentifier();
if (!nextId.equals(oldNode) && !affectedGroup.isMember(nextId)) {
replacementNode = nextId;
}
}
for (DataNodeStatusPair each : removedPairs) {
datanodeStatuses.add(each);
}
return replacementNode;
}
private synchronized void splitFinished(PrioritizedSplitRunner split) {
allSplits.remove(split);
pendingSplits.remove(split);
TaskHandle taskHandle = split.getTaskHandle();
taskHandle.splitComplete(split);
wallTime.add(System.nanoTime() - split.createdNanos);
scheduleTaskIfNecessary(taskHandle);
addNewEntrants();
}
public void trouverVoisinEtMaj(Vecteur point) {
/* Autour du point (i,j) */
int x = (int) point.getX();
int y = (int) point.getY();
/* Boucle: pour di allant de -1 à 1 et dj allant de -1 à 1 */
for (int di = -1; di <= 1; di++) {
for (int dj = -1; dj <= 1; dj++) {
Vecteur d = new Vecteur(x + di, y + dj);
/* Eliminer les indices inintéressants (continue) */
if (di == 0 && dj == 0) {
continue;
}
/* Eliminer les mauvais voisins */
if (!ToolsTerrain.isRunnable(circuit.getTerrain(d))) {
continue;
}
if ((di + x >= circuit.getHeight())
|| (dj + y >= circuit.getWidth())
|| (di + x < 0)
|| (dj + y < 0)) {
continue;
}
if (dist[x][y] == 0) {
if (VTools.prodScal(circuit.getDirectionArrivee(), new Vecteur(di, dj)) > 0) {
continue;
}
}
/* Compare la nouvelle distance avec la distance actuelle */
int poids = poids(di, dj);
if (dist[x + di][y + dj] > dist[x][y] + poids) {
q.remove(d);
dist[x + di][y + dj] = dist[x][y] + poids;
q.add(d);
}
}
}
}
private void updateStatus(DataNodeIdentifier oldNode, DataNodeIdentifier replacementNode) {
int segmentsPerSegmentGroup = coordinator.getSegmentsPerSegmentGroup();
DataNodeStatusPair oldPair = null;
DataNodeStatusPair newPair = null;
for (DataNodeStatusPair eachPair : datanodeStatuses) {
if (oldNode.equals(eachPair.getIdentifier())) {
oldPair = eachPair;
} else if (replacementNode.equals(eachPair.getIdentifier())) {
newPair = eachPair;
}
}
oldPair.getStatus().addStoredSegments(-1 * segmentsPerSegmentGroup);
newPair.getStatus().addStoredSegments(segmentsPerSegmentGroup);
datanodeStatuses.remove(oldPair);
datanodeStatuses.remove(newPair);
datanodeStatuses.add(oldPair);
datanodeStatuses.add(newPair);
}
Inits(RealVoltDB rvdb, int threadCount) {
m_rvdb = rvdb;
m_config = rvdb.m_config;
// determine if this is a rejoining node
// (used for license check and later the actual rejoin)
if (m_config.m_startAction.doesRejoin()) {
m_isRejoin = true;
} else {
m_isRejoin = false;
}
m_threadCount = threadCount;
m_deployment = rvdb.m_catalogContext.getDeployment();
// find all the InitWork subclasses using reflection and load them up
Class<?>[] declaredClasses = Inits.class.getDeclaredClasses();
for (Class<?> cls : declaredClasses) {
// skip base classes and fake classes
if (cls == InitWork.class) continue;
if (cls == COMPLETION_WORK.class) continue;
if (InitWork.class.isAssignableFrom(cls)) {
InitWork instance = null;
try {
Constructor<?> constructor = cls.getDeclaredConstructor(Inits.class);
instance = (InitWork) constructor.newInstance(this);
} catch (Exception e) {
VoltDB.crashLocalVoltDB("Critical error loading class " + cls.getName(), true, e);
}
m_jobs.put(instance.getClass(), instance);
}
}
// make blockers and blockees symmetrical
for (InitWork iw : m_jobs.values()) {
for (Class<? extends InitWork> cls : iw.m_blockers) {
InitWork blocker = m_jobs.get(cls);
blocker.m_blockees.add(iw.getClass());
}
}
// collect initially ready jobs
List<Class<? extends InitWork>> toRemove = new ArrayList<Class<? extends InitWork>>();
for (Entry<Class<? extends InitWork>, InitWork> e : m_jobs.entrySet()) {
if (e.getValue().m_blockers.size() == 0) {
toRemove.add(e.getKey());
m_readyJobs.add(e.getValue());
}
}
}
public static void main(String[] args) {
PriorityBlockingQueue<Event> queue = new PriorityBlockingQueue<Event>();
Thread[] taskThreads = new Thread[5];
// 初始这 5 个任务线程。
for (int i = 0; i < taskThreads.length; i++) {
Task task = new Task(i, queue);
taskThreads[i] = new Thread(task);
}
// 启动这 5 个任务线程。
for (Thread t : taskThreads) {
t.start();
}
// 使用 join() 方法，让 main 线程等待 5 个任务线程结束。
for (Thread t : taskThreads) {
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.printf("Main: Queue Size: %d\n", queue.size());
for (int i = 0; i < taskThreads.length * 1000; i++) {
Event event = queue.poll();
System.out.printf("Thread %s: Priority %d\n", event.getThread(), event.getPriority());
}
System.out.printf("Main: Queue Size: %d\n", queue.size());
System.out.printf("Main: End of the program\n");
}
public Dijkstra(Circuit circuit) {
super();
this.circuit = circuit;
dist = new double[circuit.getHeight()][circuit.getWidth()];
/* Initialisation du tableau de distance */
for (int i = 0; i < dist.length; i++) {
for (int j = 0; j < dist[0].length; j++) {
dist[i][j] = Double.POSITIVE_INFINITY;
}
}
q = new PriorityBlockingQueue<Vecteur>(100, new ComparatorDijk(dist));
l = new ArrayList<UpdateEventListener>();
/* Initialisation du tas */
for (Vecteur v : circuit.getListeArrivees()) {
q.add(v);
dist[(int) v.getX()][(int) v.getY()] = 0;
}
compute();
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((arrayBlockingQueue == null) ? 0 : arrayBlockingQueue.hashCode());
result = prime * result + ((arrayDeque == null) ? 0 : arrayDeque.hashCode());
result = prime * result + ((arrayList == null) ? 0 : arrayList.hashCode());
result = prime * result + ((bar == null) ? 0 : bar.hashCode());
result = prime * result + ((blockingDeque == null) ? 0 : blockingDeque.hashCode());
result = prime * result + ((blockingQueue == null) ? 0 : blockingQueue.hashCode());
result = prime * result + ((collection == null) ? 0 : collection.hashCode());
result =
prime * result + ((concurrentLinkedQueue == null) ? 0 : concurrentLinkedQueue.hashCode());
result =
prime * result + ((concurrentSkipListSet == null) ? 0 : concurrentSkipListSet.hashCode());
result =
prime * result + ((copyOnWriteArrayList == null) ? 0 : copyOnWriteArrayList.hashCode());
result =
prime * result + ((copyOnWriteArraySet == null) ? 0 : copyOnWriteArraySet.hashCode());
result = prime * result + ((deque == null) ? 0 : deque.hashCode());
result = prime * result + ((hashSet == null) ? 0 : hashSet.hashCode());
result =
prime * result + ((linkedBlockingDeque == null) ? 0 : linkedBlockingDeque.hashCode());
result =
prime * result + ((linkedBlockingQueue == null) ? 0 : linkedBlockingQueue.hashCode());
result = prime * result + ((linkedHashSet == null) ? 0 : linkedHashSet.hashCode());
result = prime * result + ((linkedList == null) ? 0 : linkedList.hashCode());
result = prime * result + ((list == null) ? 0 : list.hashCode());
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + ((navigableSet == null) ? 0 : navigableSet.hashCode());
result =
prime * result + ((priorityBlockingQueue == null) ? 0 : priorityBlockingQueue.hashCode());
result = prime * result + ((priorityQueue == null) ? 0 : priorityQueue.hashCode());
result = prime * result + ((queue == null) ? 0 : queue.hashCode());
result = prime * result + ((set == null) ? 0 : set.hashCode());
result = prime * result + ((sortedSet == null) ? 0 : sortedSet.hashCode());
result = prime * result + ((stack == null) ? 0 : stack.hashCode());
result = prime * result + ((treeSet == null) ? 0 : treeSet.hashCode());
result = prime * result + ((vector == null) ? 0 : vector.hashCode());
return result;
}
/**
* Submit a MeasurementTask to the scheduler. Caller of this method can broadcast an intent with
* MEASUREMENT_ACTION to start the measurement immediately.
*/
public boolean submitTask(MeasurementTask task) {
try {
// Immediately handles measurements created by user
if (task.getDescription().priority == MeasurementTask.USER_PRIORITY) {
return this.taskQueue.add(task);
}
if (taskQueue.size() >= Config.MAX_TASK_QUEUE_SIZE
|| pendingTasks.size() >= Config.MAX_TASK_QUEUE_SIZE) {
return false;
}
// Automatically notifies the scheduler waiting on taskQueue.take()
return this.taskQueue.add(task);
} catch (NullPointerException e) {
Logger.e("The task to be added is null");
return false;
} catch (ClassCastException e) {
Logger.e("cannot compare this task against existing ones");
return false;
}
}
/** {@link java.lang.Thread#run()} */
@Override
public void run() {
while (!(isExit())) {
try {
log.debug("trying to take from queue...");
EventHandler h = handlersQueue.take();
log.debug("took from the queue. executing " + h.getClass().getSimpleName());
h.handle();
} catch (InterruptedException ie) {
log.fatal("EXCEPTION: Module Interrupted " + ie.getMessage());
} catch (ClassCastException cce) {
log.fatal("EXCEPTION: " + cce.getMessage());
cce.printStackTrace();
}
}
}
public void run() {
MPacket received = null;
MPacket current = null;
int prevSeqNum = 0;
Client client = null;
if (Debug.debug) System.out.println("Starting ClientListenerThread");
while (true) {
try {
received = (MPacket) mSocket.readObject();
if (received.event == MPacket.HELLO) {
MPacket helloResp = new MPacket(localClient.getName(), MPacket.HELLO, MPacket.HELLO_RESP);
mSocket.writeObject(helloResp);
}
if (amServer.get()) {
if (received.type == MPacket.ACTION_REQUEST) {
if (Debug.debug) System.out.println("Received Request Packet: " + received);
eventQueue.add(received);
} else if (received.type == MPacket.REBROADCAST) {
if (Debug.debug) System.out.println("Received Rebroadcast Packet: " + received);
eventQueue.add(received);
}
} else {
if (received.type == MPacket.ACTION || received.type == MPacket.SYNC) {
if (Debug.debug) System.out.println("Received Sequence Packet: " + received);
listenerQueue.add(received);
System.out.println("LISTENER QUEUE: " + listenerQueue);
} else if (received.type == MPacket.REBROADCAST) {
if (Debug.debug) System.out.println("Received Rebroadcast Packet: " + received);
eventQueue.add(received);
}
}
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
/**
* Called from {@link Request#finish(String)}, indicating that processing of the given request has
* finished.
*
* <p>Releases waiting requests for <code>request.getCacheKey()</code> if <code>
* request.shouldCache()</code>.
*/
void finish(Request request) {
// Remove from the set of requests currently being processed.
synchronized (mCurrentRequests) {
mCurrentRequests.remove(request);
}
if (request.shouldCache()) {
synchronized (mWaitingRequests) {
String cacheKey = request.getCacheKey();
Queue<Request> waitingRequests = mWaitingRequests.remove(cacheKey);
if (waitingRequests != null) {
if (VolleyLog.DEBUG) {
VolleyLog.v(
"Releasing %d waiting requests for cacheKey=%s.", waitingRequests.size(), cacheKey);
}
// Process all queued up requests. They won't be considered as in flight, but
// that's not a problem as the cache has been primed by 'request'.
mCacheQueue.addAll(waitingRequests);
}
}
}
}
private void handleMeasurement() {
if (!userConsented()) {
Logger.i("Skipping measurement - User has not consented");
return;
}
try {
MeasurementTask task = taskQueue.peek();
// Process the head of the queue.
if (task != null && task.timeFromExecution() <= 0) {
taskQueue.poll();
Future<MeasurementResult> future;
Logger.i("Processing task " + task.toString());
// Run the head task using the executor
if (task.getDescription().priority == MeasurementTask.USER_PRIORITY) {
sendStringMsg("Scheduling user task:\n" + task);
// User task can override the power policy. So a different task wrapper is used.
future = measurementExecutor.submit(new UserMeasurementTask(task));
} else {
sendStringMsg("Scheduling task:\n" + task);
future = measurementExecutor.submit(new PowerAwareTask(task, powerManager, this));
}
synchronized (pendingTasks) {
pendingTasks.put(task, future);
}
MeasurementDesc desc = task.getDescription();
long newStartTime = desc.startTime.getTime() + (long) desc.intervalSec * 1000;
// Add a clone of the task if it's still valid.
if (newStartTime < desc.endTime.getTime()
&& (desc.count == MeasurementTask.INFINITE_COUNT || desc.count > 1)) {
MeasurementTask newTask = task.clone();
if (desc.count != MeasurementTask.INFINITE_COUNT) {
newTask.getDescription().count--;
}
newTask.getDescription().startTime.setTime(newStartTime);
submitTask(newTask);
}
}
// Schedule the next measurement in the taskQueue
task = taskQueue.peek();
if (task != null) {
long timeFromExecution =
Math.max(task.timeFromExecution(), Config.MIN_TIME_BETWEEN_MEASUREMENT_ALARM_MSEC);
measurementIntentSender =
PendingIntent.getBroadcast(
this,
0,
new UpdateIntent("", UpdateIntent.MEASUREMENT_ACTION),
PendingIntent.FLAG_CANCEL_CURRENT);
alarmManager.set(
AlarmManager.RTC_WAKEUP,
System.currentTimeMillis() + timeFromExecution,
measurementIntentSender);
}
} catch (IllegalArgumentException e) {
// Task creation in clone can create this exception
Logger.e("Exception when cloning task");
sendStringMsg("Exception when cloning task: " + e);
} catch (Exception e) {
// We don't want any unexpected exception to crash the process
Logger.e("Exception when handling measurements", e);
sendStringMsg("Exception running task: " + e);
}
persistState();
}
public void makeRequest(final CacheRequest request) {
requests.put(request);
}
