How to make a service start automatically when Android is turned on

Configure a monitor to start the broadcast in the list, and enable the service after receiving the broadcast.

If it has already been started, then startseervice has no effect;

The lifecycle of a service is one less than the lifecycle method of an activity.

Some, only oncreate, onstart, ondestroy

We have two ways to start a service, they have a service lifecycle.

The impact is not the same.

1；via startservice:

The service will go through oncreate->onstart, and when stopservice is directly ondestroy, if the caller (testserviceholder) exits directly without calling stopservice, the service will always run in the background. The next time testserviceholder gets up again, you can stopservice.

2: via bindservice:

Service will only run oncreate, and the testserviceholder and testservice will be bound together.

TestServiceHolder exits, and Srevice calls onunbind->ondestroyed, and the so-called bindings together will coexist and die.

Then a student asked, what would happen if these methods were intertwined?

One principle is that the oncreate method of the service will only be called once, no matter how many times you do.

startservice is also bindservice, and service is created only once. If it is bind first, then the onstart method of the service will be run directly when start, and if it is start first, then the onbind method will be run directly when bind. If you bind it first, yes.

Stop can't be dropped, yes, it's just that stopservice is not good, you can only unbindservice first, and then stopservice, so there is a difference between starting first or bind first.

You only need to restartService to recall onstart() of Service.

A service is an application component that runs in the background for an indefinite period of time and does not interact with the user. Each service must be declared in the manifest. It can be started by and .

Service, like any other application component, runs on the main thread of the process. This means that if a service requires a lot of time-consuming or blocking operations, it needs to be implemented in its child threads.

Two modes of service (startservice() bindservice().

1.The local service is used inside the application.

It can be up and running until someone stops it or it stops on its own. In this way, it starts with a call and ends with a call. It can be called or to stop itself.

No matter how many times you call the startservice() method, you only need to call stopservice() once to stop the service.

It is used to implement some time-consuming tasks of the application itself, such as querying upgrade information, and does not occupy the thread to which the application belongs, such as activity, but executes in the background of a single thread, so that the user experience is better.

2.Remote Service is used between applications inside the Android system.

It can be programmed through its own defined and exposed interfaces. The client establishes a connection to the service object and calls the service through that connection. The connection is established by calling the method to call close.

Multiple clients can be bound to the same service. If the service is not loaded at this point, bindservice() will load it first.

intent mservice = new intent(this, ;

stopservice(mservice );Stop serviceintent mservice = new intent(this, ;

startservice(mservice );Start the service.

The Android system has its own set of methods for memory management, in order to ensure the orderly and stable operation of the system, the system will automatically allocate and control the memory usage of the program. When the system feels that the current resources are very limited, in order to ensure that some high-priority programs can run, it will kill some programs or services that he thinks are unimportant to free up memory. This ensures that programs that are really useful to the user are still running.

If this happens to your service, it will most likely be killed first. But if you increase the priority of the service to keep it a little longer, we can use setforeground(true) to set the priority of the service.

By default, the service is marked as background, and the currently running activity is generally marked as foreground, which means that if you set a foreground to the service, then it will have a similar priority as the running activity. When making this doesn't guarantee that you'll never be killed, it just raises his priority.

The more laborious way to do this is to stop it after each stop, and then go to Settings - the application, the running program, and stop it; In general, it won't start automatically or install a program management software, but there are some built-in services to manage these applications, and there may not be a way to turn it off automatically.

Does it mean the ** implementation?

There are generally two types.

startservice()-stopself()/stopservice();

bindservice()-onunbind();

It is recommended to see the relevant instructions in the development documentation, and find an example to practice, which is very simple.