 Hello everyone, my name is Mr. Sandesh Pare, I am going to introduce you the mobile app functionality in this video lecture. I am currently working as an assistant professor in the department of computer science and engineering at Walchand Institute of Technology, Solapur. Now we will see what will be the outcomes of this learning. At the end of this video session, you will be able to understand the different types of mechanisms which implement mobile specific app functionality that are typically the part of the event handling logic which is related to the app user interfaces. Now we all know that the process is the basic component in every app but the process for convenience is again divided into the number of threads. That threads are related to the processes but only one thread which is called as the main thread is related to the process which is having the same ID as the process and all the sub threads are under that threads which are also called as the child threads of that parent thread which holds the different ID which executes the different sub task of that process and executes and again results back to the main parent thread. So we are basically implementing the app of the counter which you can see in the show that counter activity is going on and at that start counter and stop counter are the two buttons which related to the same after the starting the counter will start and the value will get incremented and at the stop it will stop and we can reset the value by pressing the reset button. So this is the counter functionality of a thread and at the starting when it is called the renewable instance is passed as a parameter to this function and it against call to the renewable interface is overrated in that we can see the run function which going on during its execution and then the display value should display the counter value and we can call the click function for the click event by calling the start method. This diagram is related to the handler and looper. As we discussed earlier there is one main thread which is called as the parent thread which calls another child threads which executes its sub task and gives the result to the parent thread which is also called as the main thread. You can see the execution of the main thread which is going on in infinite loop during its execution time and there are number of non user filters threads. These are the sub threads which are the child threads and for the execution the main thread have to require the handler which communicates with all non UI threads and get the information according to that and these messages are kept at the message queue which is maintained by the main thread and after its results are taken by the main thread these are include from that queue. There is one more factor that is called as the async task. The main purpose of the async task is to manage the ongoing long threads which are at the background and collect the result from that and again execute the parent thread simultaneously. So the basic task of the async task is to handle the different sub task or the child task which are going at the background in continuous manner and the whole program is containing the description about that. Now we will jump to the service another one component which is related to this one so the difference between the threads and service is that service is also is going on at the background at the continuous manner but it is a one component it is not one sub task of any thread this is the mobile applications one major component which is going on in continuous manner at the bank route and it is resides there at the lifetime. As we can see in the diagram of the service states and its lifecycle this process starts when the start service method is invoked. Whenever the at first start service is invoked the service is great created and after that on start command it came into the active session and that is running always at the background and provides the various services like the time or the fonts which are required for the mobile app and after that again when we call the stop service or the stop self these are two methods for the stopping the service and on destroy it get destroyed. So there is no need to refreshment of any kind during its service it gets refreshed after a certain time interval we have to just put their start and stop buttons for the counters program which is running continuous manner at the background. Now there is one question for you guys that is which are the main aspects with which the async task has to deal with and how it achieves those aspects so the async task has to handle with the mainly two aspects that is execute the long-running task which is going on at the background and update the main thread that main thread after its completion to achieve this the async task provides mainly two callback methods that is doing progress doing background and on progress update as we discussed earlier. Now there is one more factor that is bound service. Bound service you can see the lifetime and its diagram at the front it is invoked at the bind service method calling and get created and on bind it comes into a picture in the active state and during its lifetime it goes on working and after the unbind service it gets unbind that is stops its activity and on destroy it get destroyed. So the difference between the bound service and the disparate from the service and the threads that is we can take the example of a certain library that is if you want to search any certain book if we having full details of that it makes our various easy to find out that book otherwise we have to search it in the whole library isn't it so if some partial information is also available then it can be also helpful for example name of author or the publication so in that manner if we know the name of the component then we can bound it very easy manner otherwise we have to search it in certain way and bound service is unlike service it means it is going on the background process at continuous manner only the difference is that we have to bind it and then again we have to retrieve the information from it and again we and we don't have any aspect of the information from that we are unbounding from that but it doesn't mean that that activity is stopped at the background so it goes on the continuous manner at its lifetime so only we have to deal with the user end so you can see the counter value it gets replicated in the locket it is also one more important issue make it note that we have to bind and unbind as you can see and the counter value is displayed there and after some time we have to make a refresh unlike the service okay we have to continuously make refresh to get the continuous value of the count so another there are other functionalities related to the mobile apps there are the notification during its lifetime when we are working with center mobile app there are many of notification which comes into the picture related to the app or maybe at the system for example availability of Wi-Fi or incoming calls and SMS or various factors there are a lot of notification which comes into the picture so actually notification handler has to deal with it second one is the intent and intent resolution it means various factors are there which related to the intents and we have to deal with that intents third one is the broadcast receivers that is related also for the notification that is various messages coming through the various apps and systems during its lifetime so the broadcast receiver is responsible to get that information and to deal with that and other functionalities are the telephony and SMS these are the various basic aspects which we have to deal with this like calling and making the text messages like that these are few references I use while making this video so thank you