Develop Reference

Call ExectuorService with time interval - android

i used a custom thread to fetch data in the background every 1 second by making a thread goes to sleep, but my App crashes and throws exception OutOfMemoryError. Now i read a documentation in android developer and i understand that using custom thread is bad practice as it is difficult to manage the memory consistency. but finally i found ExecutorService very interesting when we need to do some tasks on background So, i decided to use it.
As You know the ExecutorService is like below:
public void executeTask()
{
ExecutorService executroService = new Executor.newSingleThreadExecutor();
executroService.execute(new Runnable()
{
#Override
publi void run()
{
// now execute the server request
}
});
}
Now how can i achive calling to executorService every 1 second untill the user goes to onpause() state or untill the user shifts from the current activity to another activity? if i use a custom thread to call that service, the App goes to crash. so how can i achive that ?

What you need is a ScheduledExecutorService
It can schedule commands to run after a given delay,
or to execute periodically.
Here is a code that implements this
import static java.util.concurrent.TimeUnit.*;
class BeeperControl {
private final ScheduledExecutorService scheduler =
Executors.newScheduledThreadPool(1);
public void beepForAnHour() {
Runnable beeper = () -> System.out.println("beep");
ScheduledFuture<?> beeperHandle =
scheduler.scheduleAtFixedRate(beeper, 10, 10, SECONDS);
Runnable canceller = () -> beeperHandle.cancel(false);
scheduler.schedule(canceller, 1, HOURS);
}
}

What is the way to make an infinite loop in a thread? android

I want to make an infinite loop in android, to check if some apps are active.
What is the best way to do this without using too much cpu?
Maybe a while loop or a handler or something?
Thanks,
Peter

Use a Handler:
import android.os.Handler;
// Create the Handler
private Handler handler = new Handler();
// Define the code block to be executed
private Runnable runnable = new Runnable() {
#Override
public void run() {
// Insert custom code here
// Repeat every 2 seconds
handler.postDelayed(runnable, 2000);
}
};
// Start the Runnable immediately
handler.post(runnable);
To remove the execution of the runnable:
handler.removeCallbacks(runnable);

You could do something like
while(true)
Just make sure to use a break when you want to exit.
You also could do something like this:
boolean run = true;
while(run)
{
if()//Whatever you want to cause the loop to stop.
{
run = false;
}
}

I would not use an infinite loop in a thread. I would use a scheduled task like this. From SO
private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
scheduler.scheduleAtFixedRate(yourRunnable, 8, 8, TimeUnit.HOURS);
Then you can customize how frequently you want it to run by changing the TimeUnit to however frequently you need the thread to run.

Call an async task repeatedly (lets say every 10 seconds) using tasktimer

My requirement is to call an async task repeatedly every 10 seconds so that the webservice will fetch data an do the update (updating of a map and image) accordingly.
I searched throughout and found out that one can use a tasktimer for this. The problem I am facing is that a parameter is passed into my asynctask. But I am not able to pass that parameter into the tasktimer.
I found out that for this a separate class should be created which extends timer task. But I have no idea how to get that done according to my need.
Please be kind enough to help me. The code for passing a parameter to the async task is given below.
new AsyncLoadGpsDetails().execute(userName);
I want to repeatedly perform the async task. PLease help me, I don't know how to create the class which extends tasktimer as I'm a newbie to this.
Thanks & Regards in advance

You can use either use scheduleAtFixedRate or scheduleWithFixedDelay...
scheduleAtFixedRate
// this task for specified time it will run Repeat
repeatTask.scheduleAtFixedRate(new TimerTask() {
#Override
public void run() {
// Here do something
// This task will run every 10 sec repeat
}
}, 0, 10);
scheduleWithFixeDelay
scheduler.scheduleWithFixedDelay(new TimerTask() {
#Override
public void run() {
// Here do something
// This task will run every 10 sec Delay
}
},, 0, 10, TimeUnit.SECONDS);
Find the difference between them Here

Here is an example of a Timer and TimerTask:
private Timer mTimer;
private TimerTask mTimerTask;
private void launchTimerTask() {
mTimer = new Timer();
mTimerTask = new TimerTask() {
#Override
public void run() {
// Perform your recurring method calls in here.
new AsyncLoadGpsDetails().execute(userName);
}
};
mTimer.schedule(mTimerTask, // Task to be executed multiple times
0, // How long to delay in Milliseconds
10000); // How long between iterations in Milliseconds
}
private void finishTimerTask() {
if (mTimerTask != null) {
mTimerTask.cancel();
}
if (mTimer != null) {
mTimer.purge();
mTimer.cancel();
}
}
For the TimerTask you will need the following imports:
import java.util.Timer;
import java.util.TimerTask;
If possible, I would use a ScheduledExecutor (Java Timer vs ExecutorService?). There are many examples around, but here is a quick snippet:
private ScheduledExecutorService mService;
private ScheduledFuture mFuture;
private void launchScheduledExecutor() {
mService = Executors.newSingleThreadScheduledExecutor();
mFuture = mService.scheduleAtFixedRate(new Runnable() {
#Override
public void run() {
// Perform your recurring method calls in here.
new AsyncLoadGpsDetails().execute(userName);
}
},
0, // How long to delay the start
10, // How long between executions
TimeUnit.SECONDS); // The time unit used
}
private void finishScheduledExecutor() {
if (mFuture != null) {
mFuture.cancel(true);
}
if (mService != null) {
mService.shutdown();
}
}
Be sure to shutdown the ExecutorService when you're done.
For the above snippet you'll need the following imports:
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
You can call launch anywhere (an onClickListener or onCreate perhaps). Just be sure to call 'finish' at some point or they will run indefinitely (in the onDestroy for example)

Taking a picture with 2 secs of delay

Is there a way to take a picture two seconds after the Camera.takePicture method is invoked? For some reason, I do not want to use handler/timer to schedule the invocation of takePicture.
Precisely, I would like to use a different solution than the following one:
final Handler handler = new Handler();
Timer t = new Timer();
t.schedule(new TimerTask() {
public void run() {
handler.post(new Runnable() {
public void run() {
<here takePicture is invoked>
}
});
}
}, 2000);

You could use AlarmManager with a PendingIntent and handle taking the camera capture in your Activity.onNewIntent method, but it is a very confusing solution for what you are trying to solve (a much better use of AlarmManager is to schedule tasks so that they are performed even if the user exits your application). This solution also requires more code and is less precise/reliable and less efficient than using a Handler.
EDIT: You can also use a ScheduledThreadPoolExecutor along with a Runnable.
(Personal opinion following) If you are exploring the APIs available in Android for performing timed tasks, that is ok, but I wouldn't use AlarmManager to schedule timed tasks within an Activity that's already running.
If you just want to have the code a bit more organised, you can make an inner class that implements Runnable and schedule your action like this:
class MyCameraActivity extends Activity
{
class TakePictureTask implements Runnable
{
public void run()
{
MyCameraActivity.this.takePicture();
}
}
void scheduleCameraShot()
{
(new Handler(this.getMainLooper())).postDelayed(new TakePictureTask(), 2000);
}
}

Destroying Runnable in android

I am using the following code to access a url:
final Handler handler = new Handler();
Runnable runnable = new Runnable()
{
public void run()
{
img.setImageBitmap(returnBitmap("fromurl"));
handler.postDelayed(this, 50);
}
};
handler.postDelayed(runnable, 2000);
I observed that if the server is not up the app takes ages to close correctly if I hit the back button. Is there anyway way I could speed up the exit procedure.

Runnables will exit automatically when finished with their run() method. If you are employing a loop to do some work, the solution that Jay Ho suggested will help exit from the loop cleanly. If you want to prevent the Handler from executing the runnable (before it posts) you can use handler.removeCallbacksAndMessages(null)1 to clear the queue. Placing it in onDestroy() is your best bet. Otherwise, you're on your own. Once you've spawned a thread, you're at the mercy of the Android operating system to terminate it once its done.
Side note: I've run into problems like this before, and it's usually a call to a system service or the implementation of a Broadcast Listener or Alarm that mucks up the exit process.

private Runnable runnable = new Runnable() {
private boolean killMe=false;
public void run() {
//some work
if(!killMe) {
img.setImageBitmap(returnBitmap("fromurl"));
handler.postDelayed(this, 50);
}
}
public void kill(){
killMe=true;
}
};
ThreadPoolExecutor threadPoolExecutor = Executors.newSingleThreadExecutor();
Runnable longRunningTask = new Runnable();
// submit task to threadpool:
Future longRunningTaskFurure = threadPoolExecutor.submit(longRunningTask);
... ...
// At some point in the future, if you want to kill the task:
longRunningTaskFuture.cancel(true);
... ...