## Character arithmetic in C and C++

As already known character known character range is between -128 to 127 or 0 to 255. This point has to be kept in mind while doing character arithmetic. To understand better let’s take an example.

`// C program to demonstrate character arithmetic.`

`#include <stdio.h>`

`int` `main()`

`{`

`char` `ch1 = 125, ch2 = 10;`

`ch1 = ch1 + ch2;`

`printf("%d\n", ch1);`

`printf("%c\n", ch1 - ch2 - 4);`

`return` `0;`

`}`

Output:

```-121
y```

So %d specifier causes an integer value to be printed and %c specifier causes a character value to printed. But care has to taken that while using %c specifier the integer value should not exceed 127.
So far so good.

But for c++ it plays out a little different.

Look at this example to understand better.

`// A C++ program to demonstrate character`

`// arithmetic in C++.`

`#include <bits/stdc++.h>`

`using` `namespace` `std;`

`int` `main()`

`{`

`char` `ch = 65;`

`cout << ch << endl;`

`cout << ch + 0 << endl;`

`cout << char(ch + 32) << endl;`

`return` `0;`

`}`

Output:

```A
65
a```

Without a ‘+’ operator character value is printed. But when used along with ‘+’ operator behaved differently. Use of ‘+’ operator implicitly typecasts it to an ‘int’. So to conclude, in character arithmetic, typecasting of char variable to ‘char’ is explicit and to ‘int’ it is implicit.

Disclaimer: This does not belong to TechCodeBit, its an article taken from the below
source and credits.
source and credits:http://www.geeksforgeeks.org/character-arithmetic-c-c/
We have built the accelerating growth-oriented website for budding engineers and aspiring job holders of technology companies such as Google, Facebook, and Amazon
If you would like to study our free courses you can join us at

#technicalguide

## Difference between %d and %i format specifier in C language

A format specifier is a sequence formed by an initial percentage sign (%) indicates a format specifier, which is used to specify the type and format of the data to be retrieved from the stream and stored into the locations pointed by the additional arguments. In short it tell us which type of data to store and which type of data to print.

For example — If we want to read and print integer using scanf() and printf() function, either %i or %d is used but there is subtle difference in both %i and %d format specifier.

%d specifies signed decimal integer while %i specifies integer.

%d and %i behave similar with printf

There is no difference between the %i and %d format specifiers for printf. Consider a following example.

`// C program to demonstrate`

`// the behavior of %i and %d`

`// with printf statement`

`#include <stdio.h>`

`int` `main()`

`{`

`int` `num = 9;`

`// print value using %d`

`printf("Value of num using %%d is = %d\n", num);`

`// print value using %i`

`printf("Value of num using %%i is = %i\n", num);`

`return` `0;`

`}`

Run on IDE

```Output:
Value of num using %d is = 9
Value of num using %i is = 9```

%d and %i behavior is different in scanf

%d assume base 10 while %i auto detects the base. Therefore, both specifiers behaves differently while they are used with an input specifier. So, 012 would be 10 with %i but 12 with %d.

• %d takes integer value as signed decimal integer i.e. it takes negative values along with positive values but values should be in decimal otherwise it will print garbage value. Consider a following example.
• %i takes integer value as integer value with decimal, hexadecimal or octal type.
To enter a value in hexadecimal format — value should be provided by preceding “0x” and value in octal format — value should be provided by preceding “0”.

Consider a following example.

`// C program to demonstrate the difference`

`// between %i and %d specifier`

`#include <stdio.h>`

`int` `main()`

`{`

`int` `a, b, c;`

`printf("Enter value of a in decimal format:");`

`scanf("%d", &a);`

`printf("Enter value of b in octal format: ");`

`scanf("%i", &b);`

`printf("Enter value of c in hexadecimal format: ");`

`scanf("%i", &c);`

`printf("a = %i, b = %i, c = %i", a, b, c);`

`return` `0;`

`}`

Run on IDE

```Output:
Enter value of a in decimal format:12
Enter value of b in octal format: 012
Enter value of c in hexadecimal format: 0x12
a = 12, b = 10, c = 18```

Explanation:
The decimal value of a as 12 is 12
The decimal value of b as 12(octal) is 10

Disclaimer: This does not belong to TechCodeBit, its an article taken from the below
source and credits.
source and credits:http://www.geeksforgeeks.org/difference-d-format-specifier-c-language/
We have built the accelerating growth-oriented website for budding engineers and aspiring job holders of technology companies such as Google, Facebook, and Amazon
If you would like to study our free courses you can join us at

#technicalguide

## Variations of “%d” Format Specifier in C

Format specifiers can be defined as the operators which are used in association with printf() function for printing the data that is referred by any object or any variable. When a value is stored within a particular variable then you cannot print the value stored in the variable straightforwardly without using the format specifiers. You can retrieve the data that are stored in the variables and can print them onto the console screen by implementing these format specifiers in a printf() function.

Format specifiers start with a percentage % operator and followed by a special character for identifying the type of the data. There are different types of basic format specifiers in C language and there variations may be helpful in Output Formatting .

Basic format Specifiers in C

Variations of “%d” format specifier

`int c = 12345;`
```// Right Justification
printf("%2d\n", c);```
``` // Left Justification
printf("%-2d\n", c);```

`// C program to illustrate`

`// Variations of %d format specifier`

`#include <stdio.h>`

`int` `main()`

`{`

`int` `c = 12345;`

`// Right Justification`

`printf("%2d\n", c);`

`printf("%10d\n", c);`

`printf("%010d\n", c);`

`printf("%010.2d\n", c);`

`printf("%010.6d\n", c);`

`printf("%+010.6d\n", c);`

`// Left Justification`

`printf("%-2d\n", c);`

`printf("%-10d\n", c);`

`printf("%-010d\n", c);`

`printf("%-010.2d\n", c);`

`printf("%-10.6d\n", c);`

`return` `0;`

`}`

Output:

```12345
12345
0000012345
12345
012345
+012345
12345
12345
12345
12345
012345```

Explanation :

• Numeral preceding ‘d’ defines the minimum length of output should be 2 with right justification but here the length of output is more than 2 (i.e. 5). So full length of the variable will be is printed.

• int c = 12345; printf(“%2d\n”, c);

• `OUTPUT:"12345"`
• Numeral preceding ‘d’ defines the minimum length of output should be 10 with right justification but unlike the previous example here, the length of output is less than 10.So in this case the output would be right justified with total length of 10.

• printf(“%10d\n”, c);

• `OUTPUT:"_____12345"`
• Numeral preceding ‘d’ defines the minimum length of output should be 10 with right justification but when the numeral is preceded with ‘0’ then all the blank spaces when right justified is filled with zero…but incase it is preceded by any other digit it is considered in the minimum length of output.

• printf(“%010d\n”, c);

• `OUTPUT:"0000012345`
NOTE: BUT similar is not the case with LEFT Justification for this case. In Left Justification no preceding zeroes are printed.
• Numeral preceding ‘d’ defines the minimum length of output should be ’10’ with right justification as in above example and the number (here, 2) after decimal signifies the relative number of zeroes to be preceded by the output and the zeroes are printed in case the relative number comes out to be greater than zero(0), relative number of zeroes means (number — length of ‘c’) i.e. (2–5=-3). It would be more clear in the coming example.

• printf(“%010.2d\n”, c);

• `OUTPUT:"_____12345"`
• Numeral preceding ‘d’ defines the minimum length of output should be ’10’ with right justification as in above example and the number (here, 6) after decimal signifies the relative number of zeroes to be preceded by the output and the zeroes are printed in case the relative number comes out to be greater than zero(0), relative number of zeroes means (number — length of ‘c’) i.e. (6–5=1).Since, 1 is greater than zero it would be reflected in the output.

• printf(“%010.6d\n”, c);

• `OUTPUT:"____012345"`
• ‘+’ sign preceded before all combination of numerals forces the compiler to use ‘+’symbol before output, the sign symbol is not counted in the length of the output

• printf(“%+010.6d\n”, c);

• `OUTPUT:"____+012345"`

Disclaimer: This does not belong to TechCodeBit, its an article taken from the below
source and credits.
source and credits:http://www.geeksforgeeks.org/variations-d-format-specifier-c/
We have built the accelerating growth-oriented website for budding engineers and aspiring job holders of technology companies such as Google, Facebook, and Amazon
If you would like to study our free courses you can join us at

#technicalguide

## Data Types in C

Each variable in C has an associated data type. Each data type requires different amounts of memory and has some specific operations which can be performed over it. Let us briefly describe them one by one:

Following are the examples of some very common data types used in C:

char: The most basic data type in C. It stores a single character and requires a single byte of memory in almost all compilers.
int: As the name suggests, an int variable is used to store an integer.
float: It is used to store decimal numbers (numbers with floating point value) with single precision.
double: It is used to store decimal numbers (numbers with floating point value) with double precision.

Different data types also have different ranges upto which they can store numbers. These ranges may vary from compiler to compiler. Below is list of ranges along with the memory requirement and format specifiers on 32 bit gcc compiler.

```Data Type             Memory (bytes)          Range                      Format Specifier
short int                   2          -32,768 to 32,767                       %hd
unsigned short int          2           0 to 65,535                            %hu
unsigned int                4           0 to 4,294,967,295                     %u
int                         4          -2,147,483,648 to 2,147,483,647         %d
long int                    4          -2,147,483,648 to 2,147,483,647         %ld
unsigned long int           4           0 to 4,294,967,295                     %lu
long long int               8          -(2^63) to (2^63)-1                     %lld
unsigned long long int      8           0 to 18,446,744,073,709,551,615        %llu
signed char                 1          -128 to 127                             %c
unsigned char               1           0 to 255                               %c
float                       4                                                  %f
double                      8                                                  %lf
long double                 12                                                 %Lf```

We can use the sizeof() operator to check the size of a variable. See the following C program for the usage of the various data types:

`#include <stdio.h>`

`int` `main()`

`{`

`int` `a = 1;`

`char` `b ='G';`

`double` `c = 3.14;`

`printf("Hello World!\n");`

`//printing the variables defined above along with their sizes`

`printf("Hello! I am a character. My value is %c and "`

`"my size is %lu byte.\n", b,sizeof(char));`

`//can use sizeof(b) above as well`

`printf("Hello! I am an integer. My value is %d and "`

`"my size is %lu bytes.\n", a,sizeof(int));`

`//can use sizeof(a) above as well`

`printf("Hello! I am a double floating point variable."`

`" My value is %lf and my size is %lu bytes.\n",c,sizeof(double));`

`//can use sizeof(c) above as well`

`printf("Bye! See you soon. :)\n");`

`return` `0;`

`}`

Output:

```Hello World!
Hello! I am a character. My value is G and my size is 1 byte.
Hello! I am an integer. My value is 1 and my size is 4  bytes.
Hello! I am a double floating point variable. My value is 3.140000 and my size i
s 8 bytes.
Bye! See you soon. 🙂```

Disclaimer: This does not belong to TechCodeBit, its an article taken from the below
source and credits.
source and credits:http://www.geeksforgeeks.org/data-types-in-c/
We have built the accelerating growth-oriented website for budding engineers and aspiring job holders of technology companies such as Google, Facebook, and Amazon
If you would like to study our free courses you can join us at

#technicalguide

## Use of bool in C

The C99 standard for C language supports bool variables. Unlike C++, where no header file is needed to use bool, a header file “stdbool.h” must be included to use bool in C. If we save the below program as .c, it will not compile, but if we save it as .cpp, it will work fine.

`int` `main()`

`{`

`bool` `arr[2] = {true, false};`

`return` `0;`

`}`

If we include the header file “stdbool.h” in the above program, it will work fine as a C program.

`#include <stdbool.h>`

`int` `main()`

`{`

`bool` `arr[2] = {true, false};`

`return` `0;`

`}`

Disclaimer: This does not belong to TechCodeBit, its an article taken from the below
source and credits.
source and credits:http://www.geeksforgeeks.org/bool-in-c/
We have built the accelerating growth-oriented website for budding engineers and aspiring job holders of technology companies such as Google, Facebook, and Amazon
If you would like to study our free courses you can join us at

#technicalguide

## Guess Game using rand() and srand() in C

Using srand() and rand() function in C, a simple but interesting game can be made. This game is called “Guess Game” .

Rules of the Game :

• There are three holes . A rat is hidden in one of those three holes.
• The Rat shuffles its position every time.
• You have to guess the hole in which the Rat is hidden among the three holes.
• The hole in which Rat is present is named as ‘R’ and rest two are named as ‘N’.
• You have some cash(inhand_cash) with you.
• You make a bet (amount_bet) for playing this game every time you make a guess.
• If your guess is wrong, you loose the amount_bet from your inhand_cash.
• If you guess is right, you win twice the amount_bet in your inhand_cash.
• Keep playing and keep winning until you go out of cash.

Below is the code in C for this simple and interesting game:

Note : As this game takes input from the players for their inhand_cash, bet_amount and the guessed location of the rat, so this will not run in online compiler.

```// Cpp program for guessing game
// using rand() and srand()
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void GuessGame(int amount_bet, int* inhand_cash)
{
char Hole[3] = { 'N', 'R', 'N' };
printf("\nWait !! Rat is shuffling its position...\n");
srand((time(NULL)));
int i, x, y, temp;

/*Swapping the Rat's (R's) position  five times using
the random number for random index*/

for (i = 0; i < 5; i++) {
x = rand() % 3;
y = rand() % 3;
temp = Hole[x];
Hole[x] = Hole[y];
Hole[y] = temp;
}

int PlayerGuess;

printf("\nYou may now guess the hole in which Rat is present: ");

scanf("%d", &PlayerGuess);

if (Hole[PlayerGuess - 1] == 'R') {
(*inhand_cash) += 2 * amount_bet;
printf("You win ! The holes are as follows: ");
printf("\"%c %c %c\" ", Hole[0], Hole[1], Hole[2]);
printf("\nYour inhand_cash is now = %d \n", *inhand_cash);
}

else {
(*inhand_cash) -= amount_bet;
printf("You Loose ! The holes are as follows: ");
printf("\"%c %c %c\" ", Hole[0], Hole[1], Hole[2]);
printf("\nYour inhand_cash is now = %d \n", *inhand_cash);
}
}

int main()
{
int amount_bet, inhand_cash;
/*
You have to guess the hole in which the
Rat is hidden among three holes
The hole in which Rat is present is
named as 'R' and rest two are named as 'N'
If your guess is wrong, you loose the
If you guess it right, you win
twice the amount_bet in your inhand_cash
Keep playing and keep winning
until you go out of cash
*/

printf("----Enter the inhand_cash you have right now---- : ");

scanf("%d", &inhand_cash);

while (inhand_cash > 0) {
printf("\nEnter the amount_bet you want to play for : ");
scanf("%d", &amount_bet);
if (inhand_cash == 0 || amount_bet > inhand_cash)
break;
GuessGame(amount_bet, &inhand_cash);
}

if (inhand_cash == 0 || amount_bet > inhand_cash) {
printf("\n\""
" 🙁 Sorry you don't have enough cash to play more, ");
printf("Do come next time\""
"\n");
printf("Thank You for playing 🙂 \n");
}
return 0;
}
```

Note: This output is not taken from online compiler
Output:

```----Enter the inhand_cash you have right now---- : 1

Enter the amount_bet you want to play for : 1

Wait !! Rat is shuffling its position...

You may now guess the hole in which Rat is present: 1
You Loose ! The holes are as follows: "N N R"
Your inhand_cash is now = 0

" :-( Sorry you don't have enough cash to play more, Do come next time"
Thank You for playing :-)

```

Disclaimer: This does not belong to TechCodeBit, its an article taken from the below
source and credits.
source and credits:http://www.geeksforgeeks.org/guess-game-using-rand-srand-c/
We have built the accelerating growth-oriented website for budding engineers and aspiring job holders of technology companies such as Google, Facebook, and Amazon
If you would like to study our free courses you can join us at

#technicalguide

## Programming languages one should learn in 2018

A quite frequent development has been observed over the past few years in programming languages, the old ones are getting replaced by the new one. It’s very important for us to be updated with the current trends of programming languages in the market in order to promote latest technological innovations. According to the trends observed in stackoverflow, freelancing websites, job market in the top multi-national companies and the startups, here are the best programming languages that will take over the market in 2018.

1. # Python

Frankly speaking, python has to be on the top of all and the reason behind that is big data analysis and machine learning. There are many of the latest technologies that use python as their core language. It is a great start for the beginners and in the year 2017 it has been observed that it has been gaining the trust of young developers. Whether we consider penetration testing or the frameworks like django for designing web apps or the analysis of data like numpy, pandas or matplotlib this language has shown its supreme power in every aspect.

2. # PHP

It is one of the languages that are widely used in a number of websites. Statistics show that it is being used 80% of the top 10 million websites in some way or the other, including WordPress, Wikipedia and Facebook. It has great flexibility and performance in solving the problems. You can find many of the frameworks that are developed in PHP like Laravel framework, which is used for developing large web applications. It is considered to be a good choice for web development for the server side scripting.

3. # Javascript

There is an insane growth in the usage of this language also. You might have not used it to its fullest and there were lot of flaws in this language but it has been improved quite a lot in 2017. Now you can handle almost everything with it. You can work with Node.js in the backend and for front end you can use Angular.js and React.js and can completely rely on it. If we consider mobile applications, ionic framework and react native framework are completely able to handle all the android and IOS apps and that’s the main reason behind why the companies like Facebook are shifting towards javascript for their web, android, IOS or any other implementation.

4. # C#

It is one of the most advanced and convenient programming languages. It is not just a main development language for the Microsoft .NET framework but also getting popular in game development and Xambrin. Gaming industry is on a boom nowadays, platforms like Unity and Blender are widely on demand and if we talk about mobile development in for android, iOS or Windows Phone, Xambrin is something that uses C# class and libraries for development of all the three mobile platforms. So for developing apps you will not have to learn the specific language for each platform.

5. # R

Another programming language which is widely used for machine learning. It is said to be the rival of python. It has great features of data visualization for the data analysis. Most of the machine learning algorithms can be easily implemented in R. These are the reasons why it has stolen the limelight of python a bit.

6. # Swift

This language was developed by Apple in order to replace Objective-c. Apple sells a very high amount of devices every year regardless of their price and quality. Therefore there is a huge ecosystem for all those who want to develop applications and software for the apple based devices. Swift is the only way for them to do so. It has improved code readability and many more exciting features in comparison to Objective-c. It is now very popular and has dominated Objective-c.

7. # SQL

How can we forget the heart of internet! SQL is still on the top because of it great usage in internet and database management system. Every other company needs to design a database and for that SQL knowledge is must for them.

8. # Kotlin

As we know that Kotlin has been declared as the official language for the android application development with Android Studio, therefore from 2018 there will be a high demand for its programmers. Along with java it can be used for android app development. We will see a gradual depletion of java and dominance of Kotlin in Android Studio in the coming years. That’s why specially the upcoming android developers should learn Kotlin in order to get recognition in the IT sector.

Moreover, the languages C, C++ and Java cannot be ignored. These are the core languages of Computer Science and Engineering and they will still prevail in the industry.

Disclaimer: This does not belong to TechCodeBit, its an article taken from the below
source and credits.
source and credits:http://www.geeksforgeeks.org/programming-languages-one-learn-2018/
We have built the accelerating growth-oriented website for budding engineers and aspiring job holders of technology companies such as Google, Facebook, and Amazon
If you would like to study our free courses you can join us at

#technicalguide

## Components of an Android Application

There are some necessary building blocks that an Android application consists of. These loosely coupled components are bound by the application manifest file which contains description of each component and how they interact. The manifest file also contains the app’s metadata, its hardware configuration and platform requirements, external libraries and required permissions.

There are the following main components of an android app:-

1. ## Activities-

Activities are said to be the presentation layer of our applications. The UI of our application is build around one or more extensions of the Activity class. By using Fragments and Views, activities set the layout and display the output and also respond to the users actions.
An activity is implemented as a subclass of class Activity.

```public class MainActivity extends Activity {
}

```
2. ## Services-

These are like invisible workers of our app. These components run at backend, updating your data sources and Activities, triggering Notification and also broadcast Intents. They also perform some tasks when applications are not active. A service can be used as a subclass of class Service:

```public class ServiceName extends Service {
}

```
3. ## Content Providers-

It is used to manage and persist the application data also typically interact with SQL database. They are also responsible for sharing the data beyond the application boundaries. The Content Providers of a particular application can be configured to allow access from other applications, and the Content Providers exposed by other applications can also be configured.
A content provider should be a sub class of the class ContentProvider.

```public class contentProviderName extends  ContentProvider {
public void onCreate(){}
}

```
4. ## Intents-

It is a powerful inter-application message-passing framework. They are extensively used throughout Android. Intents can be used to start and stop Activities and Services, to broadcast messages system-wide or to an explicit Activity, Service or Broadcast Receiver or to request an action be performed on a particular piece of data.

They are known to be intent listeners as they enable your application to listen the Intents that satisfy the matching criteria specified by us. Broadcast Receivers make our application to react to any received Intent thereby making them perfect for creating event driven applications.

6. ## Widgets-

These are the small visual application components that you can find on the home screen of the devices. They are special variation of Broadcast Receivers that allow us to create dynamic, interactive application components for users to embed on their Home Screen.

Notifications are the application alerts that are used to draw user’s attention to some particular app event without stealing focus or interrupting the current Activity of the user. They are generally used to grab user’s attention when the application is not visible or active, particularly from within a Service or Broadcast Receiver. Examples: E-mail popups, Messenger popups etc.

Disclaimer: This does not belong to TechCodeBit, its an article taken from the below
source and credits.
source and credits:http://www.geeksforgeeks.org/components-android-application/
We have built the accelerating growth-oriented website for budding engineers and aspiring job holders of technology companies such as Google, Facebook, and Amazon
If you would like to study our free courses you can join us at

#technicalguide

## Serverless Computing

Serverless computing is the technology of abstracting the servers, operating systems and the infrastructures. It is a cloud computing execution model in which the cloud provider dynamically manages the allocation of the machine resources. When we are building the serverless application, it helps us in taking our minds off from the infrastructure concerns because we do not need to manage any of the servers. The developers can dedicate their focus on their core products instead of worrying about managing operating systems or configurations for it. In this way lot of time and energy of the developers be saved. They can make use of single services (like S3 for storage or Auth0 for identity management) and elastic computer platforms like AWS Lambda or Microsoft Azure to execute code. Such serverless systems can grow, scale and evolve without requiring the developer’s efforts of remembering to patch the web servers again and again.

The main advantages of the serverless applications are:

1. The regular maintenance of any servers is not required. Also, we there is no software or platform to install for it.
2. The scaling of the application is very flexible in serverless computing. They can be scaled automatically by adjusting the capacity of the configurations required to run the application. Ex:- Memory, processor requirement etc.
3. They have inbuilt availability and fault tolerance. We do not have to decide the architect for these capabilities as they are by default provided by the services that are running the app.
4. You don’t have to pay for idle capacity. There is no need to pre- or over-provision capacity for things like compute and storage. For example, there is no charge when your code is not running.

Serverless computing is more cost-effective than purchasing the servers with required configurations. The features like more efficient bin-packing of the underlying resources of machine can make it more cost-efficient than provisioning an autoscaling group.

Some famous platforms for serverless computing:

1. # AWS lambda

It stands for Amazon Web Services Lambda. It is the platform of Amazon that executes our code only when we need and also has the features of automatic scaling, from a few requests per day to thousands per second. We have to pay for the time we consume to use it and there is no charge when our code is not running.

2. # Microsoft Azure

This is the platform provided by Microsoft. It also provides all the features and here also we have to pay for the time we use its services. It is known to improve developer productivity, focus on business goals and building intelligent apps.

It is Google’s online platform that is based on serverless computing. It is a suite of cloud computing services that runs on the same infrastructure that is used by the Google internally for its end-user products.

Disclaimer: This does not belong to TechCodeBit, its an article taken from the below
source and credits.
source and credits:http://www.geeksforgeeks.org/serverless-computing/
We have built the accelerating growth-oriented website for budding engineers and aspiring job holders of technology companies such as Google, Facebook, and Amazon
If you would like to study our free courses you can join us at

#technicalguide

## Android System Architecture

The Android software stack generally consists of a Linux kernel and a collection of C/C++ libraries that is exposed through an application framework that provides services, and management of the applications and run time. The android has the components that are shown in the figure below:

# Linux Kernel

Android was created on the open source kernel of Linux. One main reason for choosing this kernel was that it provided proven core features on which to develop the Android operating system. The features of Linux kernel are:

1. ## Security:

The Linux kernel handles the security between the application and the system.

2. ## Memory Management:

It efficiently handles the memory management thereby providing the freedom to develop our apps.

3. ## Process Management:

It manages the process well, allocates resources to processes whenever they need them.

4. ## Network Stack:

It effectively handles the network communication.

5. ## Driver Model:

It ensures that the application works. Hardware manufacturers can build their drivers into the Linux build.

# Libraries:

Running on the top of the kernel, the Android framework was developed with various features. It consists of various C/C++ core libraries with numerous of open source tools. Some of these are:

1. ## The Android runtime:

The Android runtime consist of core libraries of Java and ART(the Android RunTime). Older versions of Android (4.x and earlier) had Dalvik runtime.

2. ## Open GL(graphics library):

This cross-language, cross-platform application program interface (API) is used to produce 2D and 3D computer graphics.

3. ## WebKit:

This open source web browser engine provides all the functionality to display web content and to simplify page loading.

4. ## Media frameworks:

These libraries allow you to play and record audio and video.

5. ## Secure Socket Layer (SSL):

These libraries are there for Internet security.

# Android Runtime:

It is the third section of the architecture. It provides one of the key components which is called Dalvik Virtual Machine. It acts like Java Virtual Machine which is designed specially for Android. Android uses it’s own custom VM designed to ensure that multiple instances run efficiently on a single device.

The Delvik VM uses the device’s underlying Linux kernel to handle low-level functionality,including security,

# Application Framework

The Android team has built on a known set proven libraries, built in the background, and all of it these is exposed through Android interfaces. These interfaces warp up all the various libraries and make them useful for the Developer. They don’t have to build any of the functionality provided by the android. Some of these interfaces include:

1. ## Activity Manager:

It manages the activity lifecycle and the activity stack.

2. ## Telephony Manager:

It provides access to telephony services as related subscriber information, such as phone numbers.

3. ## View System:

It builds the user interface by handling the views and layouts.

4. ## Location manager:

It finds the device’s geographic location.

# Applications:

Android applications can be found at the topmost layer. At application layer we write our application to be installed on this layer only. Examples of applications are Games, Messages, Contacts etc.

Disclaimer: This does not belong to TechCodeBit, its an article taken from the below
source and credits.
source and credits:http://www.geeksforgeeks.org/android-system-architecture/
We have built the accelerating growth-oriented website for budding engineers and aspiring job holders of technology companies such as Google, Facebook, and Amazon
If you would like to study our free courses you can join us at