Kindle Application Lifecycle

Hello, everyone. Hope you are fine and doing well in your daily routine. Here is the 3rd part of my series of tutorials on Amazon Kindle Application Development. Note : So far we have discussed the following topics in this category. In this part I will describe some core concepts that one must know before starting development on the Kindle platform. It includes the life cycle of the Kindle application and some other key points we have to care about during code. Earlier i was going to start the Hello World tutorial, but I felt these things should be discussed first so that when one starts writing his/her first program, he/she should be clear about what's going on at the backend. So let start. I have brought my bowl of “fruit salad,” but my music player is silent today. I’m not in the mood to listen to any track, but while reading these lines, don’t forget to follow the traditions. You must have something to eat and listen, having relax seat in your chair … Alright, here we go...

Active Content

First of all, we need to know what "active content" is. Within the community of Kindle developers, you will hear this term time and again. Active content is nothing but the apps that runs over kindle device. Simply the apps for Kindle, here we call them "active conten”t. Simple it is.

Kindlet

Technically, kindlet is an interface in kdk (kindle development kit). We extends its subclass and write our code. At little abstract level, the main entrance of our kindle application is called kindlet. For example like any java program must have a class that contains main() method; to start application from that point (.i.e.  via main() method) same in case of kindle app, there must be a class that must extend subclass of kindlet interface (AbstractKindlet class) and hence become entry point of our kindle app. Such class is normally refer as kindlet of our kindle app. In more concise words, if someone asks you where is your kindlet, then it means he/she is asking about the entry point of your kindle application, the class which extends the subclass of kindlet interface of kdk .i.e  AbstractKindlet class.

Lifecycle of Kindle application

Like every application, active contents have also a defined life cycle. Our application move in between these life cycle phases during its execution and terminates from its exit point.  There are four phases application move among. They are
  • loaded
  • ready to run
  • running
  • shutdown
when application jumps into a phase, a specific method is called, defined in kindlet interface. These method calls and phase changes are very well defined until any unchecked exception is thrown, that causes the active content to die/shut down and user will see crash. Now as application crashed, there isn’t no surety whether the life cycle will complete normally or will terminate immediately. The kindlet method associates with above mentioned phases are
  • create()
  • start()
  • stop()
  • destroy()
Refer the following image describing the phases and method calls during the life cycle of kindle application  

{src : kdk documentation}

Lets discuss different phases of life cycle

Loaded

When we chose a kindle application to run, its kindlet initialized, along with other static initialization of application. Once this happened, its means kindlet object has been constructed and properly initialized, hence application has LOADED. At this stage, we don’t see any screen/user interface at user end. Its all occurred at backend. At developer lever, we don’t have access to persistent storage; we haven’t access to application environment/context.
  • After loaded phase, there are two possible ways. Either application will enter in “ready to run” phase or will “shutdown”. In case of shutdown kindlet will not notified.

Ready to run

In case application are eligible for “ready to run” then a transition is occur via method called create() declaired in Kindlet interface. At this stage application gain access to kindle environment and we have a reference of KindletContext object. This object represents the Kindle application's environment for a Kindlet and provides access to the Kindlet's user interface, filesystem space, network connectivity and more. Once a Kindlet create method has finished, the Kindlet is considered "ready to run". The application's user interface is not visible while in the "ready to run" state and no user input will be received. be patient The next phase from "ready to run" is to "running". During this start() method of kindlet interface will be called. Even at this point, the user interface is still not visible. "ready to run" to "shutdown" is also possible. If this occurs, destroy will be called. During destroy, the application should release any resources it has allocated.

Running Phase

The end of start() method moves the application in running state. At this point user interface become visible and application is said to be running state. User  can start using application.
  • Note: one thing  need to know. When user plug usb cable to device,  then  the device goes to screen saver and its stop() method calls for current running application. You can't use device when its plug with usb cable. The stop() method should pause any executing work, release any file or network resources, and prepare for the user interface to be made invisible. At this stage application move to “ready to run” state again.

Shutdown State

When use wants to quit the application, the application moves to shutdown state and stop () method is called. This pause any executing work, release any file or network resources, and prepare for the user interface to be made invisible. That’s was a theoretical concepts for life cycle of a kindle application. Let have a quick glance over life cycle methods of kindlet.

create

is the first step in the life cycle. A reference to the application's environment is provided to this method. This method will only be called once during the life of the Kindlet instance.

start

indicates that the application is about to become active. Upon completion of the start method, the user interface will become visible and the application will start to receive events from the user. Unlike create, start may be called many times during the overall life of the Kindlet instance. For instance, entering and exiting the screensaver results in a stop event followed by a start event. Similar cases exist for USB and other system notifications.

stop

indicates that the application should stop. The user interface will become invisible shortly after this method completes. When the user interface becomes invisible any open option panes will be closed. Stop will be called on a running application when the Kindle enters USB mode, screensaver or exits the application. When an application is stopped, the file system may disappear. It is important for applications to close resources like files and re-open them on stop / start cycles, respectively. Additionally, any threads that are performing work should either shutdown or sleep. This includes network access, and all requests for connectivity may be cancelled on stop.

destroy

indicates that the Kindlet instance will not be used again. This permits the Kindlet to clean up resources and do any housekeeping that may be necessary on application exit. The device may choose to shutdown an application during screen saver or USB mode to preserve battery life. Its enough for today .. in next part, we will move to actual development, a hello world program. though i start working that part today but i felt we should discuss these things first so that while writing the code, we should know what actually going inside code and at backend of our application. feel free to ask any thing confusing here. i will try my best to make it more simple, easy to understand as per your kind suggestions. Be blessed. Have a nice day. free counters