You will find slide deck (ppts) for all the units with programming examples.

Also, few model question papers are provided for reference.

Python_Application_Programming_VTU

The post Python Application Programming Course Material VTU, Belagavi appeared first on Software Artist.

Step 1: Ensure the Windows Machine and Raspberry Pi are part of the same Network.

Step 2: Install PyCharm Professional Edition on you Windows machine.

Step 3: You need to get the IP Address of Raspberry Pi. To do so, open the Terminal window on raspberry pi and type the following command ifconfig

As can be seen from the screenshot, Raspberry Pi is connected to the Wireless LAN and the address is 172.16.2.100. It may vary on your Raspberry Pi. Make a note of this address.

Step 4: Once you have obtained the Address, go to your home directory and create a folder as shown in the below screenshot. This folder is used to store the Python programs.

Step 5: Invoke your PyCharm IDE. Create a new Project. Go to File → New Project → Pure Python → Give a Project Name. In my case it is RaspberryPiProject.

Step 6: Right Click on RaspberryPiProject and select New → Python File and give a name to python file. In my case it is rasp.py

Step 7: Write the line print “Hello RaspberryPi” in the editor.

Step 8: Now go to File  → Settings

On the left pane of the window you should see Project:RaspberryPiProject. (If you have given a different name then it may differ from what is displayed here) Expand it and Click on Project Interpreter

On the right pane of the window, click at the end of Project Interpreter and select Add Remote option as shown below.

A Remote Python Interpreter window pops up.

Step 9: Configure the Remote Python Interpreter window.

Write the IP address of the Raspberry Pi you earlier made note of in the Host option. Give the user name and password. Specify the Python interpreter path on raspberry pi. Click OK. Now you should see the Python Interpreter found in Raspberry Pi.

Step 10:  Now go to Tools à Deployment → Configuration and click on + sign on the left pane. You should see a window.

At this stage RaspberryPi will be treated as a Server machine. Give a name to your RaspberryPi server (in my case it is GS_Research) and select the type as SFTP and click OK

Step 11: Click on the Connections tab and specify the IP address of the RaspberryPi again in SFTP host

Leave the port and Root path as it is. Specify the User Name and Password

Then click on Mappings tab.

Specify the local path where you have stored the python project in the Windows machine. Then specify the path which we had created to store the Python programs on raspberry pi i.e., /home/pi/pywork and click OK.

Step 12: Now we need to upload the Python file created on a Windows machine on to Raspberry Pi and compile the program using Raspberry Pi Python Interpreter.

Go to Tools → Deployment → Upload to GS_Research.

Remember, here GS_Research is the name given to the Raspberry Pi server. At the bottom pane, you can see that the file is successfully uploaded.

Now open the terminal window again on the Raspberry Pi and go to the path where you intended to store Python programs. If you have followed the instructions then the path is /home/pi/pywork. You should see the rasp.py file in there.

Step 13: You need to sync the Python code with Raspberry Pi as and when you write your code in PyCharm. To do that go to Tools → Deployment → Sync with Deployed to GS_Research.

Happy Coding…

The post Remote Programming of Raspberry Pi using PyCharm appeared first on Software Artist.

I thought of coming up with a naming convention for these papers based on requirements as mentioned below.

1. On any given day, I should be able to pick the exact paper belonging to a particular faculty.
2. Keep track of number of papers published by each faculty.
3. Whether the paper is published in Journal or Conference.
4. Ability to sort the papers year wise.

Based on the above requirements I devised the following way to name each file.

1. Paper name is divided into six components. Each of these components is separated by a Hyphen.
2. First component is the type of paper. If the paper is published in International Journal then use the Keyword IJ, likewise for International Conference use IC, for National Journal use NJ and for National Conference use NC
3. Second component is the name of the concerned faculty. Use the first three letters of the faculty name. For e.g., if the faculty name is Patrick.G.S then the second component will be PAT.
4. Third component is the initials of the concerned faculty. So w.r.t. the above name the third component will be GS (exclude dots).
5. Fourth component is the month in which the paper was published. For e.g., if the paper is published in the month of March then use the numeral 03. (prefix 0 for single digits)
6. Fifth component is the year in which the paper was published. For e.g., if the paper is published in the year 2016 then it’ll be the fifth component.
7. Sixth component is the count of the number of papers the faculty has published under a particular category of IJ or IC or NJ or NC.

Based on the requirements discussed, if for e.g., Prof. Patrick.G.S has published in 2 International Journals and in 2 International Conferences then the nomenclature for these papers will be as shown below:

For International Journal

IJ-PAT-GS-03-2016-1

IJ-PAT-GS-05-2016-2

For International Conference

IC-PAT-GS-10-2016-1

IC-PAT-GS-11-2016-2

The post Nomenclature for Naming Published Research Papers appeared first on Software Artist.

The original files is as shown below having a set of characters and number separated by an “-” (hyphen) with jpg extension.

d6445cef9361a2bf-1.jpg

d6445cef9361a2bf-2.jpg

d6445cef9361a2bf-3.jpg and so on.

Here, the requirement was to remove the left part of the “-” (hyphen) and retain only the number and the extension.

So, here is my approach.

from glob import glob
import os

pathFromUser = input("Enter the Path")
files_list = glob(os.path.join(pathFromUser, '*.jpg'))
for each_file in files_list:
    number = os.path.basename(each_file).split("-")[1].split(".")[0]
    os.rename(each_file, number + ".jpg")

In line 4, we ask the user to enter the path for the folder which contains all the files. In line 5, a list of all the files in the folder is assigned to the list called files_list. One should be aware that it’s not only the filename but a combination of both path and filename i.e., C:\foldername\d6445cef9361a2bf-1.jpg. In line 6, we loop through each file in the list. In line 7, the basename method is used to obtain the name of the file from the path and then we split the filename based on “-” (hyphen) and we again split the resultant value based on “.” (dot). This line results in a number present in the file and is assigned to the variable number. Then we use the method rename to rename each file to the value that is present in the number.

The post Traverse and Rename files in folder appeared first on Software Artist.

http://csi-india.org/digital_magazine/April2016//mobile/index.html#p=21

The post Open Source Software Stack for Python Platform: From Academia to Industry appeared first on Software Artist.

This tutorial Introduces the reader to step by step instruction in using RStudio IDE with GitHub.

Using RStudio with GitHub

All these steps are tested on a Windows 10 machine with RStudio version 0.99.x. I assume that you have already already installed RStudio and GitHub. If you haven’t still installed GitHub then please follow the first 6 steps of Install GitHub portion found at

Configuring PyCharm to Work With Enthought Canopy and GitHub

Assuming that both RStudio and GitHub is configured properly, type the following two command at the command prompt.

git config –global user.name “your GitHub account name”                                                    

git config –global user.email “GitHubEmail@something.com”

Step1:

Go to your GitHub account and create an repository. To create an repository go to the upper right corner and click on the “+” sign.

A pop up appears asking you to create a New repository. Click on New repository. 

Step 2:

You will be taken to a new page and in the Repository name box write as RStudioGitHubTutorial and click on CreateRepository button.

You will be taken to the next page giving you more information about the repository you have just created.

Step 3:

Copy the URL of the Git repository you have created.

Step 4:

Start your RStudio. Go to File menu -> Click on New Project.

A window appears where in you have different ways of creating a project.

Click on Version Control.

You’ll be taken to the next window and click on Git option.

Paste the URL that you copied from step 3 in the Repository URL text box.

The Project directory name text box automatically gets filled.

Specify the directory under which this project has to be created. In my case it’s C:/RWork.

Step 5:

Go to File menu -> Select New File -> click on R Script.

This creates an empty R file. Save this file by clicking on the Save button and name this file as Tutorial.R.

Type the following line in the editor.

print “First Commit”

Save the file.

Step 6:

Click on the Git button as shown in the below figure and select Commit option.

You’ll be taken to a new window. Select all the check boxes in the left pane and in the in the Commit Message pane type as First Commit and click on Commit button.

Another windows appears saying that the commit has been carried out at the local repository. Your local repository is the as that of the Project Directory which you created in Step 4. Click on Close button.

Now click on the Push button.

You’ll be asked to enter your GitHub User Name as shown in below figure. Enter your GitHub account name and press OK button.

Then enter your GitHub password and press OK button.

Step 7:

Navigate to the repository in your GitHub account and you can see that many new files have been added.

Click on Tutorial.R file to view it’s contents.

Step 8:

Again in the RStudio editor add another line as

print(“Second Commit”)

Click on the Git button and select Commit option.

In the window that appears, on the left pane select the check box and in the Commit message right pane type Second Commit and click on Commit button.

Click on the Push button found in the right top corner. You will be asked to enter your GitHub User Name. Fill the text box with your Git Hub account name and click OK button.

Fill the text box with GitHub account password and click OK button.

You can view the latest changes by navigating to your online GitHub Account and by clicking on the Tutorial.R button.

If you want to see the history of all the changes done to the file then again click on GIT button and select History option as shown in the below figure.

Click on the appropriate Commit Message and select View File link as show in the below figure.

Conclusion

This article gives you step by step instructions on how to work with RStudio and GitHub.

The post Using RStudio with GitHub appeared first on Software Artist.

  SUBJECT CODE: 15CS822 No. of Credits:4:0:0:0 No. of Lecture hours per week:4 Exam Duration :3 hours Exam Marks: 100 Total No. of Lecture hours: 52

Course Objectives:

The objective of the course is to:

1. Vision and Introduction to IoT.
2. Understand IoT Market perspective.
3. Data and Knowledge Management and use of Devices in IoT Technology.
4. Understand State of the Art – IoT Architecture.
5. Real World IoT Design Constraints, Industrial Automation and Commercial Building Automation in IoT.

Textbook:

• Jan Holler, Vlasios Tsiatsis, Catherine Mulligan, Stefan Avesand, Stamatis Karnouskos, David Boyle, “From Machine-to-Machine to the Internet of Things: Introduction to a New Age of Intelligence”, 1^st Edition, Academic Press, 2014.

Reference Books:

• Vijay Madisetti and Arshdeep Bahga, “Internet of Things (A Hands-on-Approach)”, 1^st Edition, VPT, 2014.
• Francis daCosta, “Rethinking the Internet of Things: A Scalable Approach to Connecting Everything”, 1^st Edition, Apress Publications, 2013

NOTE: One question each from units 1, 2 and 4.

               Two questions from unit-3

               Two questions from unit-5

Course Outcomes:

At the end of the course the student will be able to:

1. Understand the vision of IoT from a global context.
2. Determine the Market perspective of IoT.
3. Use of Devices, Gateways and Data Management in IoT.
4. Building state of the art architecture in IoT.
5. Application of IoT in Industrial and Commercial Building Automation and Real World Design Constraints.

Syllabus prepared by me for the Department of Computer Science and Engineering at Dr.Ambedkar Institute of Technology, Bangalore, Karnataka, India.

The post Internet of Things (IoT) Syllabus for the Department of Computer Science and Engineering at Dr.Ambedkar Institute of Technology appeared first on Software Artist.

JSON stands for JavaScript Object Notation (http://www.json.org) and was proposed by Douglas Crockford. JSON is an easy to understand data exchange format which is independent of programming languages.

Why JSON?

JSON allows websites to load data quickly and asynchronously in the background without much delay.

JSON doesn’t have end tags like XML, is shorter than XML and lightweight.

JSON is preferred way of exchanging data in AJAX requests and in REST architecture.

JSON data is offered by API’s hosted by Google, Facebook, Microsoft, SalesForce, Twitter, LinkedIn and others.

JSON Syntax

JSON is made up of string:value pairs. An object represents these string:value pairs. An object may contain a number of individual string:value pairs or a string may contain multiple string:value pairs (nested string:value pairs) or an array of string:value pairs (array of objects) or all of these.

An object should be enclosed within parenthesis { } and an array of objects should be enclosed within square brackets [ ]. Each string is followed by a : (colon)  and each of these string:value pairs should be separated by a comma.

An object with Individual string:value pairs

This JSON object has individual string:value pairs, separated by comma and enclosed within parenthesis { }.

{
    "FirstName":"Bhairav",
    "MiddleName":"S",
    "LastName":"Ram"
}

An object with string containing multiple string:value pairs (nested string:value pairs)

This JSON object is already enclosed within parenthesis { } and also the string “Contact” has few other nested string:value pairs.

{
    "Contact":{
        "Phone":9988776655,
        "Email":"bhairav@gmail.com"
}

An object with array of string:value pairs (array of JSON objects)

This JSON object is enclosed within parenthesis { }. The string “Address” is followed by an array of JSON objects separated by comma and enclosed within brackets [ ].

{
    "Address":[
        {
            "Type":"Office",
            "ZipNumber":560056,
            "Street":"Nagarbhavi Road",
            "City":"Bangalore",
            "Country":"India"
        },
        {
            "Type":"Home",
            "ZipNumber":560004,
            "Street":"Gandhi Bazaar Road",
            "City":"Bangalore",
            "Country":"India"
        }
    ]
}

So we came across various JSON verbs like object, string:value and array. An string should be enclosed within double quotes. A value can be a number, string, object itself, true value, false value or null value.

As seen in below figure, JSON object starts at line-1 and ends at line-26. In line-7 a number value is assigned to string Phone. Nested string:value pairs starts from line-6 to line-9. An array of json objects starts from line-10 and ends at line-25.Below figure depicts how JSON verbs compare with Python identifiers.

Read JSON with Python

Here we import the package json in line-1. From line-4 to line-29, we create an JSON object. This JSON object is then converted into a string by enclosing it within quotes and is assigned to the variable input. This JSON object cannot be assigned directly to a variable, instead In line-32, we make use of the method loads in json library to convert json object into Python dictionary and assign it to a dictionary variable jsonObjectInfo. If we want to print the value of string FirstName then the code is jsonObjectInfo[‘FirstName’]. We use a for loop to loop through the array Address.

If you already have an existing json file then we can open that file using open method where f is a file handler (or TextIOWrapper) and load that file handler using open method. Here ‘r’ is the reading mode in which the file is opened. While working with a file we use the method load and not loads.

import json

input = '''
{
    "FirstName":"Bhairav",
    "MiddleName":"S",
    "LastName":"Ram",
    "DateOfBirth":"09-01-1984",
    "Contact":{
        "Phone":9988776655,
        "Email":"bhairav@gmail.com"
    },
    "Address":[
        {
            "Type":"Office",
            "ZipNumber":560056,
            "Street":"Nagarbhavi Road",
            "City":"Bangalore",
            "Country":"India"
        },
        {
            "Type":"Home",
            "ZipNumber":560004,
            "Street":"Gandhi Bazaar Road",
            "City":"Bangalore",
            "Country":"India"
        }
    ]
}
        '''
print(type(input))
jsonObjectInfo = json.loads(input)
print(type(jsonObjectInfo))
print(jsonObjectInfo)
print("First Name is {0}".format(jsonObjectInfo['FirstName']))
print("Middle Name is {0}".format(jsonObjectInfo['MiddleName']))
print("Last Name is {0}".format(jsonObjectInfo['LastName']))
print("Date of Birth is {0}".format(jsonObjectInfo['DateOfBirth']))
print("Phone Number is {0}".format(jsonObjectInfo['Contact']['Phone']))
print("Email ID is is {0}".format(jsonObjectInfo['Contact']['Email']))
print("-----------------**************---------------")
for eachJsonObject in jsonObjectInfo['Address']:
    print("Address Type is {0}".format(eachJsonObject['Type']))
    print("Zip Number is {0}".format(eachJsonObject['ZipNumber']))
    print("Street Name is {0}".format(eachJsonObject['Street']))
    print("City Name is {0}".format(eachJsonObject['City']))
    print("Country Name is {0}".format(eachJsonObject['Country']))
    print("-----------------**************---------------")


# Reading JSON data back from a file called JSONData.json
#Use the method json.load()
#It's just load and not loads()
#Decode JSON Data
with open('JSONData.json', 'r') as f:
     data = json.load(f)

print(data)

Output:

<class ‘str’>
<class ‘dict’>
{‘Address’: [{‘City’: ‘Bangalore’, ‘Street’: ‘Nagarbhavi Road’, ‘Type’: ‘Office’, ‘Country’: ‘India’, ‘ZipNumber’: 560056}, {‘City’: ‘Bangalore’, ‘Street’: ‘Gandhi Bazaar Road’, ‘Type’: ‘Home’, ‘Country’: ‘India’, ‘ZipNumber’: 560004}], ‘FirstName’: ‘Bhairav’, ‘LastName’: ‘Ram’, ‘Contact’: {‘Phone’: 9988776655, ‘Email’: ‘bhairav@gmail.com’}, ‘DateOfBirth’: ’09-01-1984′, ‘MiddleName’: ‘S’}
First Name is Bhairav
Middle Name is S
Last Name is Ram
Date of Birth is 09-01-1984
Phone Number is 9988776655
Email ID is is bhairav@gmail.com
—————–**************—————
Address Type is Office
Zip Number is 560056
Street Name is Nagarbhavi Road
City Name is Bangalore
Country Name is India
—————–**************—————
Address Type is Home
Zip Number is 560004
Street Name is Gandhi Bazaar Road
City Name is Bangalore
Country Name is India
—————–**************—————
{“FirstName”: “Bhairav”, “MiddleName”: “S”, “Address”: [{“ZipNumber”: 560056, “Street”: “Nagarbhavi Road”, “Country”: “India”, “City”: “Bangalore”, “Type”: “Office”}, {“ZipNumber”: 560004, “Street”: “Gandhi Bazaar Road”, “Country”: “India”, “City”: “Bangalore”, “Type”: “Home”}], “LastName”: “Ram”, “DateOfBirth”: “09-01-1984”, “Contact”: {“Phone”: 9988776655, “Email”: “bhairav@gmail.com”}}

Write JSON with Python

We create a Python dictionary data and is converted to JSON objects by using the method dumps from json library.

We can save the json objects into a file by using the method dump from json library. The file should be opened in write mode.

import json

data = {
    "FirstName":"Bhairav",
    "MiddleName":"S",
    "LastName":"Ram",
    "DateOfBirth":"09-01-1984",
    "Contact":{
        "Phone":9988776655,
        "Email":"bhairav@gmail.com"
    },
    "Address":[
        {
            "Type":"Office",
            "ZipNumber":560056,
            "Street":"Nagarbhavi Road",
            "City":"Bangalore",
            "Country":"India"
        },
        {
            "Type":"Home",
            "ZipNumber":560004,
            "Street":"Gandhi Bazaar Road",
            "City":"Bangalore",
            "Country":"India"
        }
    ]
}

#json.dumps() method turns a Python data structure into JSON:
jsonData = json.dumps(data)
print(jsonData)

# Writing JSON data into a file called JSONData.json
#Use the method called json.dump()
#It's just dump() and not dumps()
#Encode JSON data
with open('JSONData.json', 'w') as f:
     json.dump(jsonData, f)

Output:

{

“LastName”:”Ram”,
“Address”:[
{
“ZipNumber”:560056,
“City”:”Bangalore”,
“Country”:”India”,
“Type”:”Office”,
“Street”:”Nagarbhavi Road”
},
{
“ZipNumber”:560004,
“City”:”Bangalore”,
“Country”:”India”,
“Type”:”Home”,
“Street”:”Gandhi Bazaar Road”
}
],
“Contact”:{
“Phone”:9988776655,
“Email”:”bhairav@gmail.com”
},
“MiddleName”:”S”,
“FirstName”:”Bhairav”,
“DateOfBirth”:”09-01-1984″

}

Conclusion

The code in the article is available @ https://github.com/gowrishankarnath/JSONProcessingWithPython

The post Read and Write JSON with Python appeared first on Software Artist.

Applications are made up of a number of components which are initiated when the application starts. Each of these components have their own role in the Android ecosystem and APIs.

Four important Android Application Components are

1. Activity
2. Services
3. Broadcast Receivers
4. Content Providers

Activity

It is designed to display. It is implemented as the Java Class. Its the main class the users see when they run the application. Activity class are designed to provide GUI to the user. This enables the user to give and take information from an application. An Activity class should implement a single, focused task the user can do.

Services

The Services run in the background. Services have two purposes

1. To perform long running operation away from the main UI Thread.
2. It provides a way for different processes to request operation and share data.

Broadcast Receivers

They listen to and respond to receivers. They play the role the role of subscriber in the subscriber/publisher pattern. Events are represented by INTENT class.

Broadcast receivers receive and respond to the broadcast receivers. An e.g., of the broadcast receivers is the way an SMS is notified. The SMS application software sits waiting for SMS and it broadcasts once it receives an SMS. Then there is another application which corresponds to this intent and the notification is placed on the notification bar.

Content Providers

They allow you to store and share data across different applications. It uses database style interface. It handles low level inter-process communications so that the different applications can share data.

Building an Application

First you create source code and non source code resources that make up our application. The tool compiles the source code and prepares the resources. The output of this step is an Android package or an apk, which corresponds to an exe.

It is then digitally signed to identify that you are the developer. Then the apk is installed on a device or an emulator.

Steps in Creating an Android Application

1. Define Resources
2. Implement Application Classes
3. Package Application
4. Install and Run the Application

Define Resources

Android applications are more than source code. They include non source code entities like layouts, strings, Images, Menus and Animations.

Managing the resources separately from the application has many advantages. It allows the Applications to be customized for different devices and users. You can just change the resources and the same gets reflected on the application without changing the source code of the application.

One common resource type is string. There are three types of strings in android

1. string
2. string array
3. plurals

Plurals are basically string arrays that can be used to chose specific strings that are associated with certain quantities. Such as one book, two books.

A string is typically stored in XML file RES/Values/*.xml. For e.g., <string name = “hello”> Hello World </string>. A string can be accessed by other resources as @string/string_name. In Java a string is accessed as R.string.string_name.

User Interface Layout

The user interface layout is specified in XML files. Some tools allow visual layouts. UI related XML files are usually stored in RES/layout/*.xml.

The same can be accessed in Java using R.layout.layout_name. Other resources can access these files as @layout/layout_name.

Android allows you to create multiple layout files and it allows you to chose those layout files in runtime.

R.Java

Resources can be accessed using R.Java.something. At compilation time, resources are used to generate the R.Java class.

Implementing Java Classes

This involves implementing atleast one Java class activity. An entry point to Java class activity iis one oncreate() method. The application typically gets initialized by the oncreate() method.

Package Application

This information is written in Android Manifest.xml. This file contains wide variety of packaging information. They include the application name, list of components that make up the application, permission that need to run the application, the hardware features like camera, the minimum API level on  which this application can run.

Install and Run the application

From the Android Studio you can run in the emulator or in the device.

The Activity Class

Activity classes are the primary classes for interacting with the users. It provides a visual interface with which the user can interact with the application. An activity should be a modular. It should focus on one single task such as viewing an email message, showing a login screen. You’ll create an application by sewing together multiple activities together. Each of these activities have single purpose and the user needs to navigate through these different activities.

Navigation through Activities

Android helps in navigating through these activities in several ways. It is done through

1. Tasks
2. The Task Backstack
3. Ensure that the activities are properly suspended, resumed and destroyed as necessary

Tasks

In Android a task is a set of related activities. These related activities don’t have to be a part of the same application. Most of the tasks start at the Home screen.

Task Backstack

When an activity is launched it goes to the top of the backstack as part of the current backstack.

When that activity is destroyed when the user clicks on back button or when the application terminates itself the activity is popped off the backstack.

Backstack is nothing but a stack for different activities based on their priorities. It acts like a stack to store different activities.

The Activity Life Cycle

The Android application have a life cycle. An Activity is created, suspended, resumed and destroyed as necessary when an application executes. An application may not be in total control over the life cycle of these activities.

Some of these actions depend on the choice the user makes. Some of these depend on the android itself. If for e.g., that the device is running low on battery, the Android OS may kill some of the activities to get back the resources.

When an activity starts it can be in an Resume/Running state i.e. it’ll be visible to the user and the user can interact with it.

An activity can be paused

It may be visible but the user will not be interacting with this activity. He may be interacting with another activity. An paused activity can be terminated by the Android. When an activity is stopped it is no longer visible and can be terminated.

Android announces Activity life cycle changes to the Activity by calling specific activity methods like protected void onCreate(Bundle SavedInstanceState), protected void onStart(), protected void onResume(), protected void onRestart(), protected void onStop(), protected void onDestroy().

The Android application doesn’t work by themselves. There is an back and forth collaboration between the Android application and the Android OS itself. You have to understand the rule of these collaborations if you have to have the applications working properly.

When the activities are about to become visible then the Android calls onStart() method or sometimes the onRestart() method.

When the activity is about to become non visible then the android calls the onStop() method.

Visible lifetime of an activity is between onStart() method and onStart() method.

When an activity is visible on the screen, there are times when the user can interact with it and sometimes may not. This happens when the device goes to sleep. In that case the user cannot interact with the activity, even though the activity is in the foreground.

When the activity is again ready for the user interaction then the Android calls the onResume() method.

If the activity is able to stop interacting with the user then the Android calls the onPause() method.

If the activity is able to stop interacting with the user then the Android calls the onPause() method.

If the activity is invisible and in foreground then its life cycle is between onResume() and onPause().

onCreate()

This method is called when Activity is first created. It’ll call super.onCreate() which allows Android to do its own initialization. It’ll set the Activity’s content view. It tells what the Activity’s user interface should be. It retains and capture any information in reference to UI views as necessary. It configures the GUI views as necessary.

onRestart()

This method is called when the activity becomes visible and is about to start to interact with the user. This starts only foreground behaviors like starting animation.

onPause()

This method is called when we want to switch to another activity. For e.g., when we want to shutdown foreground only behavior.

onStop()

This method is called when the application is no longer visible to the user. May be this activity can be restarted later.

onDestroy()

This method is called when the application needs to be terminated. It helps in releasing the activity resources.

Starting Activities

Lets see how one activity can start or call another activity programmatically. First, you need to create an Intent object that specifies the activity that you need to start. Then you need to pass this newly created Intent to methods such as startActivity(), startActivityForResult().

startActivity()

This method will start the desired activity, pushing the current activity away from the foreground.

startActivityForResult()

This method will also act as startActivity() along with the desire that the started activity will return back to the called activity. This is done by calling a callback method, when the called activity finishes to return a result.

Once the new activity  is called, then it should return the result back to the calling activity. This can be done by calling  the Activity.setResult().

public final void setResult(int resultCode);

public final void setResult(int resultCode, Intent Data);

These resultCode includes some built in data like RESULT_CANCELED, RESULT_OK, CUSTOMRESULTCODE can also be added by the user.

Configuration Changes

It relates to application resources like languages, keyboard availability, service orientation. Device configuration can change at runtime. On configuration changes the Android kills the current activity and then restarts it.

Since the configuration changes happen regularly/frequently, it needs to be reflected fast. Say for e.g., if the activity orientation is landscape or portrait. The activity can go from landscape mode to portrait mode. This kills the previous activity.

To handle these changes, Java provides two ways to do this. When the changes are occurring, you can create and retain or save the objects containing important state information. Another option is to manually handle the configuration changes.

Retaining an Object

Hard to recompute data can be cached to speed up handling of configuration changes. This is done using Fragment class.

Manually handling the Reconfiguration Changes

You need to declare those specific changes that your activity will handle in AndroidManifest.xml file. For e.g., <activity android:name = “.MyActivity” android:configChanges = “orientation/screensize/keyboardhidden”>. Here the activity name is MyActivity. This will handle the changes to orientation or screen size or keyboard accessibility.

When these configuration changes occur at runtime, the activity’s onConfigurationChanged() method is called. A configuration object is passed to this method specifying the new device configuration. Then our code can read this object and make what ever changes needs to be done.

The post Android Application Fundamentals and Activity Class appeared first on Software Artist.

The Android Platform is a software stack for Mobile Devices consisting of OS Kernel, System Libraries, Application Frameworks and Key Applications.

Android provides SDK for creating Applications. Android SDK consists of libraries, development tools and lots of documentation.

The Android Architecture

Android architecture consists of different layers like Linux Kernel, Libraries, Android RunTime, Application Framework. All of these layers will be used to develop Android Applications.

Linux Kernel

It’s the lowest layer of Android. It provides Android specific generic operating system services like security, memory and process management, File and Network Input/Output.

Android has a customized Linux kernel that is specific to Android. It provides power management, memory sharing and management (due to less memory constraints of mobile devices). Inter-process communication is allowed wherein it allows several processes to communicate among themselves in a sophisticated manner.

Device drivers needs to be plugged in, so that Android software can communicate with wide range of hardware devices like memory, radio, camera etc.

System Libraries

These are written in C/C++. Hence they are called native libraries. Android has its own C library. These system C libraries handle lot of core performance sensitive activities like rendering the images, updating the pages.

System C library is also called as BIONIC LIBC. It implements standard system calls which does things like process and thread creation, mathematical computations, memory allocation and much more.

Surface manager

It updates the display

Media Framework

To play audio/video

Webkit

For rendering and displaying web pages.

OpenGL

Performs and plays high end graphics.

SQLite

Perform in memory relational database.

Android RunTime

It supports writing and running android applications. Two main components are Core Java Libraries and Dalvik Virtual Machine.

Core Java Libraries 

The Android application is written in Java programming language. So Android makes available a number of Java libraries.

The Core Java library is made up of basic Java classes like Java.*, Javax.*

Android packages that are specific to the application life cycle are android.*

Internet/Web Services packages are org.*

Unit Testing packages are JUnit.*

Dalvik Virtual Machine

Applications are executed by the Dalvik Virtual Machine (DVM). Typical workflow is

1. Application is written in Java
2. Java Compiler compiles the application to multiple Java Byte code file.
3. A tool called DX will convert the Java Byte Code file to a single DX Byte code file. (The file will have .dex extension. For e.g., classes.dex)
4. This dex file is packaged with other application resources and installed on to the devices.
5. When the user finally launches the application the Dalvik Virtual Machine executes the dex byte code file.

The reason for doing all of this or using the Dalvik Virtual Machine is DVM is designed to run in resource constrained environment which is a typical scenario for mobile devices. Resource constrained because when compared to desktop PCs/Laptops, the mobile devices have

1. Slower CPU
2. Less RAM
3. Limited Batter

Application Framework Layer

It has many reusable software components.

View System

Contains many common graphical items like buttons, icons that many applications include in their user interface.

Package Manager

Keeps track of all the packages that are currently installed on the device.

Window Manager

Manages the many windows that comprises the application.

Resource Manager

Manages non compiled resources like strings, graphics and layout files.

Activity Manager

Activity means it corresponds to single user interface screen.

An App will have multiple activity through which the user needs to navigate.

Content Providers

Content Providers are essentially databases that allows the application to store and share the structured information. Contact Content Providers stores the mobile numbers which is used by the dialler to dial the number. These are used for inter application data sharing.

Location Manager

It allows the App to access the location information and movement information. For e.g., GPS Systems.

Notification Manager

It allows applications to place the notification icons on the status bar when important events occur. For e.g., if I’m browsing and in between if I receive a message, then that SMS message icon is displayed in the notification bar. Notification bar will be at the very top row (in the battery row).

Application Layer

It contains standard applications like Home Screen, Contacts, Phone Dialer, Browser, Email reader and others. The better part is none of these apps are hard coded into Android. You can substitute these applications with better applications or any 3rd party applications.

The Android Development Environment

Android Studio is the official IDE for Android application development, based on IntelliJ IDEA. On top of the capabilities you expect from IntelliJ, Android Studio offers:

• Intelligent code editor
• Multi-screen app development, Rich layout editor with support for drag and drop theme editing
• Virtual devices for all shapes and sizes
• Code templates to help you build common app features and GitHub integration
• lint tools to catch performance, usability, version compatibility, and other problems
• Flexible Gradle-based build system
• Build variants and multiple apk file generation
• ProGuard and app-signing capabilities
• Built-in support for Google Cloud Platform, making it easy to integrate Google Cloud Messaging and App Engine

Virtual Device

The Android Emulator is called Virtual Device. Following are the Pros of Android Emulator

1. Doesn’t require an actual device.
2. Hardware characteristics can be easily reconfigured like setting the amount of memory.

Following are the Cons of Android Emulator

1. Its very slow.
2. Some features are not well supported like Bluetooth or USB connections are not supported properly.
3. Performance/User Experience can be misleading.

Debugger

Tool for examining the internal state of a running application.

DDMS
Android Studio includes a debugging tool called the Dalvik Debug Monitor Server (DDMS), which provides port-forwarding services, screen capture on the device, thread and heap information on the device, logcat, process, and radio state information, incoming call and SMS spoofing, location data spoofing, and more.

Reading and Writing Logs
The Android logging system provides a mechanism for collecting and viewing system debug output.

Logcat dumps a log of system messages, which include things such as stack traces when the emulator throws an error and messages that you have written from your application by using the Log class. You can run LogCat through ADB or from DDMS, which allows you to read the messages in real time.

Improving Your Code with lint
In addition to testing that your Android application meets its functional requirements, it’s important to ensure that your code has no structural problems.

Poorly structured code can impact the reliability and efficiency of your Android apps and make your code harder to maintain. For example, if your XML resource files contain unused namespaces, this takes up space and incurs unnecessary processing.

Other structural issues, such as use of deprecated elements or API calls that are not supported by the target API versions, might lead to code failing to run correctly

Profiling with Traceview and dmtracedump
Traceview is a graphical viewer for execution logs that you create by using the Debug class to log tracing information in your code.

Traceview can help you debug your application and profile its performance.

dmtracedump is a tool that gives you an alternate way of generating graphical call-stack diagrams from trace log files.

The tool uses the Graphviz Dot utility to create the graphical output, so you need to install Graphviz before running dmtracedump.

The dmtracedump tool generates the call stack data as a tree diagram, with each call represented as a node. It shows call flow (from parent node to child nodes) using arrows.

Analyzing UI Performance with Systrace
While developing your application, you should check that user interactions are buttery smooth, running at a consistent 60 frames per second. If something goes wrong, and a frame gets dropped, the first step in fixing the problem is understanding what the system is doing.

The Systrace tool allows you to collect and inspect timing information across an entire Android device, which is called a trace. It shows where time and CPU cycles are being spent, displaying what each thread and process is doing at any given time. It also inpects the captured tracing information to highlight problems that it observes, from list item recycling to rendering content, and provide recommendations about how to fix them.

The post Introduction to Android Platform and Android Development Environment appeared first on Software Artist.