Detailed introduction and Usage summary of Android service _android

Android Service Services Detailed

A Service Introduction

Service is one of the four major components of the Android system (activity, Service, Broadcastreceiver, ContentProvider), which is about the same level as the activity, but not the page display can only run in the background, And can interact with other components. Service can be used in many occasions, such as playing multimedia when the user started other activity this time the program to continue to play in the background, such as the detection of SD card file changes, or in the background to record your geographical information location changes, etc., in short, the service is always hidden in the background, such as , a service can handle network things, play music, perform file I/O, or interact with a content provider, all in the background.
What we must know is that the background of the service is not a child thread. The service is run in the main thread, but it has no interface to display it, its time-consuming operations also need to open the child thread, no one will be the same as the activity ANR (application not response– program does not respond).
What we need to know is that the main thread's contents include UI and background. As long as the UI or background in the program is running, the program is in the running state.

(i) Creation and registration of service services 1.Service service creation

It is necessary to implement the Onbind method, which can be done in a variety of operations, can also receive the intent data to do processing.

public class MyService extends Service {
  @Nullable
  @Override public
  ibinder onbind (Intent Intent) {
    System.out.println ("Myservice.onbind");
    return null;
  }
 }

Registration of the 2.Service service, registered in Androidmanifest

<service android:name=".MyService" />

The registration of a service is the simplest of the four components, and it is generally possible to set the Name property. However, if there are other requirements, you want to set additional property values.

After the service is created and registered, the service is ready to operate.

(ii) Service two kinds of start-up mode

There are two ways to start a service: Context.startservice () and Context.bindservice (). The context here is meant to be contextual.

1.startService () mode of life cycle callback method at startup

(1) Start service StartService: –>oncreate () –> OnStart ()
(2) Stop service StopService: –>ondestroy ()
If the caller exits without stopping the service, the service will always run in the background. The receded here simply closes the UI interface.
The StartService () method starts the service, and when the service is not created, the system invokes the OnCreate () method of the service, and then calls the OnStart () method. If the service has been created before the StartService () method is invoked, calling the StartService () method multiple times does not cause the service to be created multiple times, but will cause multiple calls to the OnStart () method. Services started with the StartService () method can only call the StopService () method to end the service, and the OnDestroy () method of the lifecycle is invoked at the end of the service.

2.bindService () mode of life cycle callback method at startup

(1) Binding Bindservice:–> onCreate () –> onbind ()
(2) Untied Unbindservice:–>onunbind ()
(3) The normal stopping procedure service method is first unbindservice the binding, then stops the service StopService.
(4) If the binding after the call StopService method, then can not stop the service, if this time to call the solution binding Unbindservice, the program after the first unbind, after the stop service.
The service is started with the Bindservice () method, and the service's OnCreate () method is invoked before the service is created, and then the Onbind () method is invoked. This time the caller and the service are bound together, the caller exits, and the system
The Onunbind () method of the service is invoked first, followed by the OnDestroy () method. If the service is already bound before the Bindservice () method is invoked, calling the Bindservice () method multiple times does not cause the service and the bindings to be created multiple times (that is, the onCreate () and Onbind () methods are not invoked more than once). If the caller wants to unbind the service being bound, the Unbindservice () method can be invoked, and invoking the method also causes the system to invoke the Onunbind ()->ondestroy () method of the service.

Binding Service Method: Bindservice (Intent, Conn, service.bind_auto_create);
Description of three parameters:
First: Intent objects
Second: Serviceconnection object that creates the object to implement its onserviceconnected () and on servicedisconnected () to determine whether the connection is successful or disconnected
Third: The pattern of creating service, which is typically specified when binding is automatically created

(iii) Callback methods for five life cycles of service

1. Cycle naming

(1) onCreate ()
(2) OnStart ()
(3) Onbind ()
(4) Onunbind ()
(5) OnDestroy ()

2. Life cycle diagram

The above shows a process that has no binding service and different scenarios for the lifecycle of a bound service.

3. A description of several methods

(1) onCreate () Description service was first created
(2) Onstartcomand () Description of the service began to work
(3) Onbind () indicates that the service has been bound
(4) Onunbind () Description service has been untied
(5) OnDestroy () Description service has been stopped
As mentioned above, there are two ways to start a service, one is to use StartService, the other is to use the Bindservice method, and there is no callback to the Startcommand method using the Bindservice method;
You can also start the service with StartService, and then bind the service to the Bindservice, and the order of the service's callback methods is:
–>oncreate () –>onstartcommand () –>onbind ()

Two Intentservice

Ordinary service to create a thread to complete the time-consuming operation, because it runs in the main thread, and to stop Intentservice is a class that inherits from the service and processes the asynchronous request, and within the intentservice there is a worker thread to handle the time-consuming operation. The way to start a intentservice is the same as starting a traditional service, and when the task is done, the Intentservice will automatically stop without the need for us to manually control it.
In addition, you can start intentservice multiple times, and each time-consuming operation executes in the Intentservice Onhandleintent callback method as a work queue, and only one worker thread is executed at a time, the first is executed and the second is executed, and so on. Also, all requests are in a single thread, which does not block the application's main thread (UI thread) and processes only one request at a time.
So what's the benefit of using Intentservice?
First, we save the trouble of manual threads in service,
Second, when the operation is complete, we do not have to manually stop the service Intentservice, a convenient class for us to handle business processes, it is a service, but more intelligent than service

Three A simple example of viewing the life cycle callback method for a service

This example is only used to look at the service life cycle by increasing the recall of the life cycle method when services are turned on, when they stop, when they are tied, when they are untied.

(i) Creating the MyService class (inheriting service)

Package com.lwz.service;
Import Android.app.Service;
Import android.content.Intent;
Import Android.os.IBinder;

  Import android.support.annotation.Nullable;
   /** * Service Creation, * Test lifecycle process and succession * Five lifecycle: * onCreate * onstartcommand * OnDestroy * onbind * * Onunbind */public class MyService extends Service {@Nullable @Override public ibinder onbind (Intent Intent) {Syste
    M.out.println ("Myservice.onbind");
  return null;
    @Override public void OnCreate () {System.out.println ("myservice.oncreate");
  Super.oncreate (); @Override public int Onstartcommand (Intent Intent, int flags, int startid) {System.out.println ("Myservice.onst

    Artcommand ");
  Return Super.onstartcommand (Intent, flags, Startid);
    @Override public void OnDestroy () {System.out.println ("Myservice.ondestroy");
  Super.ondestroy ();
    @Override public boolean onunbind (Intent Intent) {System.out.println ("Myservice.onunbind"); Return SupeR.onunbind (Intent); }
}

(ii) Registration of services in Androidmanifest

<service android:name=".MyService" />

(iii) Design control services to open, stop, bind, unbind the state of code

Package com.lwz.service;
Import Android.app.Service;
Import Android.content.ComponentName;
Import android.content.Intent;
Import android.content.ServiceConnection;
Import Android.os.Bundle;
Import Android.os.IBinder;
Import android.support.v7.app.AppCompatActivity;

Import Android.view.View;
 /** * Service creation and use * Note that the service is not dependent on the activity page, even if the page is closed, the service did not take the initiative to stop, is not closed * service is also in the main thread to perform the task, but why not cause the main thread blocking??
 * Because doing is not time-consuming operation, if do time-consuming operation can cause ANR ...
 * Click on the binding service, click the Stop service button is not valid, to first unbind, to stop the service. * Normally, the service is not stopped from the binding state to the unbound state.
 It's just a state change.
 * Click on the binding service, click the Stop service button is not valid, but after the unbind, will immediately stop the service. */public class Mainactivity extends appcompatactivity {@Override protected void onCreate (Bundle savedinstancestate
    ) {super.oncreate (savedinstancestate);
  Setcontentview (R.layout.activity_main); //Open service public void StartService (view view) {//Open service requires Intent object, and activity jumps similar to StartService (this, M

  Yservice.class)); //Stop service public void StopService (view view) {//Stop service method StopService (new inteNT (this, myservice.class)); }//Binding service public void Bindservice (view view) {//Binding service Bindservice (this, myservice.class), CONN, Fla
  GS); //Unbind service public void Unbindservice (view view) {//Prevent unbound without binding, throw exception try {//Unbind Unbindservi
    CE (conn);
    catch (Exception e) {System.out.println ("Mainactivity.unbindservice" + e); }//Service bound Connection object private Serviceconnection conn = new Serviceconnection () {@Override public void Onservic  econnected (componentname name, IBinder service) {} @Override public void onservicedisconnected (componentname

  Name) {}};


Service binding Identity//bind_auto_create binding, start service private int flags = Service.bind_auto_create; }

Above is the use of four buttons to implement the service of several state changes.

(iv) Design of layout documents

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  Android:id="@+id/activity_main"
  Android:layout_width="match_parent"
  Android:layout_height="match_parent"
  Android:orientation="vertical">

  <TextView
    Android:layout_width="wrap_content"
    Android:layout_height="wrap_content"
    Android:layout_gravity="center_horizontal"
    Android:text="Service" />

  <Button
    Android:layout_width="wrap_content"
    Android:layout_height="wrap_content"
    Android:onClick="startService"
    Android:text="start service" />

  <Button
    Android:layout_width="wrap_content"
    Android:layout_height="wrap_content"
    Android:onClick="stopService"
    Android:text="stop service" />

  <Button
    Android:layout_width="wrap_content"
    Android:layout_height="wrap_content"
    Android:onClick="bindService"
    Android:text="binding service" />

  <Button
    Android:layout_width="wrap_content"
    Android:layout_height="wrap_content"
    Android:onClick="unBindService"
    Android:text="unbundling service" />


</LinearLayout>

The above layout file code is relatively simple, just use four buttons to fix!

The interface that is displayed after the program is run:

Click the log message after the "Start Service" button:

There are two callback methods executed at this time. OnCreate and Onstartcommand.

Click the log message after the "Stop Service" button:

A callback method was executed: OnDestroy; then the service has stopped, which is equivalent to the state of the program just running!

Click the "Bind Service" button after the log information:

Two callback methods are implemented here, first start the service, then bind the service!
The service cannot be stopped when the service is bound, and the service cannot be stopped until it is untied.
When the program's service starts/binds, and then clicks on the start service, it only recalls the Onstartcommand method, which means that a service will only recall the OnCreate method once in a lifecycle.

Click the "Bind Service" button to display log information:

Two callback methods were executed: Onunbind and OnDestroy

If you are using a service to do simple things, use the first method to start the service, but if you need to involve more complex data processing and operations, use the binding service method to start the service.

Four. Examples of the use of Intentservice

Program Design: Find all the pictures in the cell phone SD card displayed on the UI interface.

(i) Layout file Activity_main.xml file actual
<?xml version= "1.0" encoding= "Utf-8"?>
xmlns: Android= "http://schemas.android.com/apk/res/android"
  android:id= "@+id/activity_main"
  android:layout_ Width= "Match_parent"
  android:layout_height= "match_parent" >


  <listview android:id=
    "@+id/main_" LV "
    android:layout_width=" match_parent "
    android:layout_height=" Match_parent "></ListView>
</RelativeLayout>

Very simple layout design, using List view to display all the pictures

(ii) The design of the tool class for traversing files

Package com.lwz.intentservice;

Import android.os.Environment;
Import android.os.StatFs;

Import java.io.File;
Import java.util.ArrayList;
Import java.util.List;

/**
 * SD card path: Environment.getExternalStorageDirectory()
 */

Public class FileUtils {

  /**
   * Get all the pictures in the specified directory
   */
  Public static final ArrayList<File> getAllPicture(File dir) {
    ArrayList<File> files = getAllFile(dir);
    ArrayList<File> imgList = new ArrayList<>();
    For (File file : files) {
      If (file.getName().endsWith(".png") || file.getName().endsWith(".jpg"))
        imgList.add(file);
    }
    Return imgList;
  }

  /**
   * Method of recursively traversing folders
   */
  Public static final void getFileFromDir(File dir, List<File> fileList) {
    File[] files = dir.listFiles();
    If (files == null)
      Return;
    For (File file : files) {
      If (file.isDirectory())
        getFileFromDir(file, fileList);
      fileList.add(file);
    }
  }

  /**
   * Get all the pictures in the root directory
   */
  Public static final ArrayList<File> getAllPicture() {
    Return getAllPicture(Environment.getExternalStorageDirectory());
  }

}

(iii) simplifies a tool class for Baseadapter

Package com.lwz.intentservice;

Import android.content.Context;
Import android.widget.BaseAdapter;

Import java.util.ArrayList;
Import java.util.List;

/**
 * This is a tool class that simplifies the BaseAdapter adapter.
 * This is to define a generic T, what data is passed in when used, what data is T?
 * In addition to the getVIew method in the actual design, the other methods are basically the same.
 * So after inheriting this tool class, just rewrite the getView method, you can use the BaseAdapter.
 */

Public abstract class ListItemAdapter<T> extends BaseAdapter {
  List<T> list = new ArrayList<>();
  Context context;

  ListItemAdapter(Context context, List<T> list) {
    This.context = context;
    This.list = list;
  }

  ListItemAdapter(Context context, T[] list) {
    This.context = context;
    For (T t : list) {
      This.list.add(t);
    }
  }

  @Override
  Public int getCount() {
    Return list == null ? 0 : list.size();
  }

  @Override
  Public T getItem(int position) {

    Return list == null ? null : list.get(position);
  }

  @Override
  Public long getItemId(int position) {
    Return position;
  }

}

(iv) Creation of Myintentservice

Package com.lwz.intentservice;

Import android.app.IntentService;
Import android.content.Intent;
Import android.os.Message;
Import android.util.Log;

Import java.io.File;
Import java.util.ArrayList;

/**
 * Use of IntentService
 * IntentService is a subclass of Service and also needs to be registered in xml
 * It has a custom child thread method
 * The main problem to be solved here is how to pass the data to the UI thread after the resource file is obtained.
 */

Public class MyIntentService extends IntentService {
  /**
   * By constructor, the name of the incoming child thread
   * But here you must create a no-argument constructor
   */
  Public MyIntentService() {
    Super("myService");
  }

  /**
   * This is the execution in the child thread
   */
  @Override
  Protected void onHandleIntent(Intent intent) {
    Log.e("TAG", "The child thread starts working");
    / / Traverse the folder to get the picture
    ArrayList<File> list = FileUtils.getAllPicture();
    / / Use the handler to send information
    Message msg = Message.obtain();
    / / Here to pass an object to the handler object
    Msg.obj = list;
    / / Send a broadcast to pass data
    Intent intent1 = new Intent("filefinish");
    Intent1.putExtra("file", list);
    sendBroadcast(intent1);
  }

  @Override
  Public void onCreate() {
    super.onCreate();
    Log.e("TAG", "onCreate");
  }

  @Override
  Public void onDestroy() {
    super.onDestroy();
    Log.e("TAG", "onDestroy");
  }
}

The registration of the intent service here is the same as the registration of intent.

(v) Code design in Mainactivity

Package com.lwz.intentservice;

Import android.content.BroadcastReceiver;
Import android.content.Context;
Import android.content.Intent;
Import android.content.IntentFilter;
Import android.net.Uri;
Import android.os.Bundle;
Import android.support.v7.app.AppCompatActivity;
Import android.view.View;
Import android.view.ViewGroup;
Import android.widget.ImageView;
Import android.widget.ListView;

Import java.io.File;
Import java.util.ArrayList;
Import java.util.List;

/**
 * Here use the service to intentService to traverse the folder
 * Start the service when the program is created.
 * Stop the service when the page is destroyed
 But after the Service finishes the task, there is still data to be passed to MainActivity.
 UI interface update in MainActivity
 This involves the data transfer problem of Service and Activity.
 Here is the use of broadcast to pass data
 */
Public class MainActivity extends AppCompatActivity {
  / / Define the controls inside the layout
  ListView listView;
  / / Define a collection of data for the adapter

  / / Must be static? ? ?
  Static ArrayList<File> fileList;
  Static MyBaseAdapter adapter;
  MyBroadcastReceiver mbcr;

  @Override
  Protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    Mbcr = new MyBroadcastReceiver();
    / / Dynamic registration of a broadcast
    IntentFilter filter = new IntentFilter();
    filter.addAction("filefinish");
    registerReceiver(mbcr, filter);// registration
    / / Create an object of the adapter
    Adapter = new MyBaseAdapter(this, fileList);
    / / Instantiate the controls inside the layout
    listView = (ListView) findViewById(R.id.main_lv);

    / / Set the adapter to the listView
    listView.setAdapter(adapter);
    / / Start the service
    startService(new Intent(this, MyIntentService.class));
  }


  / / Create an adapter class
  Class MyBaseAdapter extends ListItemAdapter<File> {

    MyBaseAdapter(Context context, List<File> list) {
      Super(context, list);
    }

    @Override
    Public View getView(int position, View convertView, ViewGroup parent) {
      ImageView image = null;
      If (convertView == null) {
        Image = new ImageView(getBaseContext());
        convertView = image;
      } else {
        Image = (ImageView) convertView;
      }
      / / Set image resources and attributes
      image.setImageURI(Uri.fromFile(fileList.get(position)));
      image.setScaleType(ImageView.ScaleType.FIT_XY);
      image.setAdjustViewBounds(true);
      Return image;
    }
  }

  //Out of service
  Public void stop() {
    stopService(new Intent(MainActivity.this, MyIntentService.class));
  }

  @Override
  Protected void onDestroy() {
    super.onDestroy();
    / / Even if the service is stopped before, stop the service again will not give an error
    Stop();
    / / Release the broadcast
    unregisterReceiver(mbcr);
  }

  / / Dynamically create a broadcast receiver
  Class MyBroadcastReceiver extends BroadcastReceiver {
    @Override
    Public void onReceive(Context context, Intent intent) {
      / / Processing the received broadcast, intent contains data
      fileList = (ArrayList<File>) intent.getSerializableExtra("file");
      / / Refresh adapter
      adapter.notifyDataSetChanged();
      / / Stop the service, its child thread will also stop
      Stop();
    }
  }


}

Before running the program, remember to add the access rights of SD card;
The above program function is still a bit of a problem! After traversing the file. The page is not updated immediately? Exit the program and then come in, the page immediately displays the image of the SD card.
Generally speaking, traverse folder is not a time-consuming operation, here is a simple demonstration.
Typical time-consuming operations are downloading data from the network, or moving large files locally, and so on.

Five Some of the ways in which service and activity are communicated in the same program, showing the main code here.

Components here don't forget to register in Androidmanifest

(i) using intent to pass code in data 1.MainActivity, sending data

Intent intent = new Intent(this, MyService.class);

intent.putExtra("msg", "activity向service传递一个hello service");

startService(intent);

Code in 2.MyService, receiving data

Here you use the Onstartcommand method to receive the intent data, and if you use the Bind method to start the service, you can receive the data in the Onbind method.

@Override public
  int Onstartcommand (Intent Intent, int flags, int startid) {
    log.e ("Onstartcommand"), Intent.getstringextra (msg));
    Return Super.onstartcommand (Intent, flags, Startid);
  }

(ii) Use of single case mode to pass data

This method is a bit of trouble! Here's a way to do a single example in the MyService class and then call the MyService object in the activity

Code in the 1.MyService

Define a static class variable, using a single example to prepare the
  private static MyService instance;

  static method, which returns an object of this class
  //The method public
  static MyService getinstance () {return
    instance;
  } for a class that can let the other side call MyService


  @Override public
  void OnCreate () {
    super.oncreate ();

    Single case pattern variable assignment
    instance = this;
  }
public void print (String msg) {
    log.e ("service", msg);
  }

Where the Print method is invoked in the activity to deliver the data to the MyService, but the service has to be started before the single example is used, because this is where the object is assigned to instance in the MyService OnCreate method, Before you can implement a single example.

Code in 2.MainActivity:

/**
   * Single case mode
   *myservice here A static method is used to get the MyService object to
get the MyService object here through the Myservice.getinstance () method
   * ///
      must ensure that the MyService object cannot be a null
    //static variable and the last release (manually =null the static variable if not necessary)
    if (myservice.getinstance ()!= null) {
      myservice.getinstance (). Print ("method to invoke a service from an activity using a single example");
    }

(iii) Broadcast data on the parameters of communication

Get two broadcast receivers to transmit data to each other.

Here to dynamically create broadcast receivers and dynamically registered broadcast receivers in MyService and MyService, and then send broadcasts in the mainactivity, after receiving the broadcast in the MyService, sending the broadcast, Let mainactivity receive broadcast data!

Code in 1.MyService:

@Override public
  void OnCreate () {
    super.oncreate ();
    Dynamically registers the broadcast receiver, to define the received action attribute value
    intentfilter filter = new Intentfilter ("service");
    Registerreceiver (servicereceiver, filter);

 Defines a broadcast receiver Broadcastreceiver
  broadcastreceiver servicereceiver = new Broadcastreceiver () {
    @Override
    public void OnReceive (context context, Intent Intent) {
      log.e ("service") received broadcasts sent by activity: "+ Intent.getstringextra ("MSG"));
Send a broadcast to mainactivity
      Sendbroadcast (New Intent ("activity"). Putextra ("msg", "message sent to activity"));
  

Code in 2.MainActivity:

@Override
  protected void onCreate (Bundle savedinstancestate) {
    super.oncreate (savedinstancestate);
    Setcontentview (r.layout.activity_main);
    Register the broadcast within this class, define the property value of the action
    intentfilter filter = new Intentfilter ("activity");
    Registerreceiver (activityreceiver, filter);

 /**
   * Transmit data via broadcast
   /public
  void Sendbroadcast (view view) {
    //indicates action attribute value
    Intent Intent = new Intent ("service");
    Intent.putextra ("MSG", "activity sends a Hello broadcast to the broadcast");
    Sendbroadcast (intent);
  }

 A broadcast receiver that defines an internal class for receiving data passed by MyService
  broadcastreceiver activityreceiver = new Broadcastreceiver () {
    @ Override public
    void OnReceive (context context, Intent Intent) {
      log.e ("Activity", Intent.getstringextra (" MSG "));
  

(iv) MyService instance invocation method

This method is the most troublesome way! Involves the use of a binder class! The method to be called here is actually not the method in the MyService, but the internal interface of the abstract method, need to implement this method in Mainactivity! However, this method is actually implemented in MyService.

Code in 1.MyService:

//define an Interface interface Callback {//define two methods to implement void call ();
  void Start ();

  //Define an Interface object Callback Callback;
   /** * Create Binder class, many many service is through binder mechanism to interact with client communication.
    * * Class Mybinder extends Binder {public MyService GetService () {return myservice.this;
    }//Set callback method public void Setcallback (Callback Callback) {MyService.this.callback = Callback; }//Define a method to simulate starting music playback//You need to rewrite the method in start to start playing music public void Startmusic () {//Play Toast.maketext (this, "music starts to broadcast
    Put ", Toast.length_short). Show ();
  Callback.start (); @Nullable @Override public IBinder onbind (Intent Intent) {//To pass a Mybinder object to mainactivity return new Mybin
  Der (); //define a method to simulate starting music playback//You need to rewrite the method in start to start playing music public void Startmusic () {//Play Toast.maketext (this, "music starts playing", to Ast.
Length_short). Show ();
  Instantiate the callback Object Callback.start () in mainactivity; }

The above code to start playing music to invoke the Startmusic method, and to instantiate the inside of the callback object, and to instantiate the callback object must call the inner class Mybinder set callback method, And the implementation of this method must implement the method of this interface!

Code in 2.MainActivity:

The/** * Binding Services service invokes the MyService method to invoke the interface method of the inner class///define a MyService object MyService myservice;
 public void Bindservice (view view) {Bindservice (The new Intent (this, myservice.class), Conn, bind_auto_create);
  Myservice.startmusic (); }//Create Serviceconnection object Serviceconnection conn = new Serviceconnection () {@Override public void Onserviceconn
      ected (componentname name, IBinder service) {//Connect services, Operation ...
      Gets the IBinder bind object, Myservice.mybinder bind = (myservice.mybinder) service that is passed over from the MyService Onbinder;
      Get service object through bind object MyService = Bind.getservice ();
        Set the callback method for the listener event and implement the two methods inside//The callback method here is not in MyService, but in the inner class Mybinder Bind.setcallback (New Myservice.callback () {

        @Override public void called () {LOG.E ("activity", "service callback activity");
          @Override public void Start () {//As playing music in the background; start playing music log.e ("Action", "playing music");
        Close page finish (); }
      });

The above relationship is really a bit messy, I found that some of my comments are still a bit of a problem!!

The above is a summary of the aspects of service.

Service can also be used to process data transfer between processes, and this involves aidl (Android Interface definition Language, an Android Interface Definition language) process communication. This is relatively complex, another summary!

Thank you for reading, I hope to help you, thank you for your support for this site!