Compose Camp

This work is licensed under the Apache 2.0 License
Compose Camp
Android Basics with Compose

A Club of the students of CTAE,
by the students of CTAE and for
the students of CTAE.
● Vision:
○ To promote each and every field of programming through Competitions.
○ To Engage each and every member of the Club in Programming through
Development and Problem Solving.
○ To help students in Resume Building.
○ To promote programming in all the branches of CTAE.

● Global Community with people from different colleges
● To organize hackathons, open source events, tech podcasts, etc.
● Connections with colleges across the country
● Official Google supported community

Compose Camp is a hands-on introduction to
learning how you can build Android apps with
Jetpack Compose.
What is Compose Camp?

● Build your first Android apps
● Set up Android Studio on your computer
● Learn the basics of the Kotlin programming
language
Compose Camp Learning Objectives

Android Basics
with Compose Course

Kotlin Programming
Language
Use Kotlin to start writing Android apps.
Kotlin helps developers be more
productive.

Kotlin Programming
Language
A statically-typed language is a
language, where variable types are
known at compile time. Kotlin is a
statically-typed language.

Kotlin Playground
Write and run Kotlin code in
the browser.

How to Print
Print displays the next text on the
same line, while println display
the next text on the next line.
println("Hello")
print("Hello, world!")
Hello
Hello, world!

Program
A series of instructions for a
computer to perform some
action.
fun main() {
println("Hello, world!")
}
Output:
Hello, world!

Code
Step by step instructions for
what the computer should do.
fun main() {
}
Output:
Hello, world!

main Function
The main function is the entry
point, or starting point, of the
program.
Start here
fun main() {
}
Output:
Hello, world!

Functions
A function is a segment of a program that
performs a specific task.
You can have many functions in your program or
only a single one.

Defining a function
Functions begin with the fun
keyword.
fun displayIntroduction() {
}

Defining a function
Functions have a name so that
they can be called.
}

Defining a function
Functions need a set of parentheses
after the function name in order to
surround the function inputs.
}

Defining a function
The curly braces make up the
function body and contain the
instructions needed to execute
a task.
}

A container for a single piece of data.
Variables

My name is and I am years old
Variables
Name variable: Athrav
Age variable: 19
Output:
My name is Athrav and I
am 19 years old
Name variable Age variable
Name variable: Subin
Age variable: 19
Output:
My name is Subin and I
am 19 years old

Basic data types
Kotlin Data type What kind of data it can contain Example literal values
String Text
“Add contact”
“Search”
Int Whole integer number
32
-59873
Double Decimal number
2.0
-37123.9999
Float
Decimal number (less precise than a Double).
Has an f or F at the end of the number.
5.0f
-1630.209f
Boolean
true or false. Use this data type when there
are only two possible values.
true
false

val keyword
Use when you expect the variable value will
not change.
Example: name
var keyword
Use when you expect the variable value can
change.
Example: age
Defining a variable

Defining a variable
Variables start with a var or val
keyword.
val name: String = "Athrav"
var age: Int = 19
}

Defining a variable
All variables must have a name.
var age: Int = 19
}

Defining a variable
Data type is the type of data
that the variable holds.
var age: Int = 19
}

Defining a variable
The initial value is the value that
is stored in the variable.
var age: Int = 19
}

Putting it together
val name = "Athrav"
val age = 28
println("Hi I'm $name and I am $age years old")
}

String Templates
val name = "Athrav"
val age = 19
}
String Templates allows you to include variable references and
expressions into strings. A template expression starts with a dollar
sign ($) and consists of either a name:

Putting it together
fun main() {
displayIntroduction()
}
val name = "Athrav"
val age = 19
}
Output:
Hi I’m Athrav and I am 19 years old

Functions with return
Statement
Function on calling perform the set of
instruction and at last return the value.
fun generateAnswerString(): String {
val answerString = if (count == 42) {
"I have the answer."
} else {
"The answer eludes me"
}
return answerString
}

Null Safety
For a variable to hold a null value,
it must be of a nullable type. You
can specify a variable as being
nullable by suffixing its type with
?
//fails to compile
Val name: String = null
//correct way
Val name: String? = null

Conditionals
Kotlin features several mechanisms for implementing conditional logic. The
most common of these is an if-else statement. If an expression wrapped in
parentheses next to an if keyword evaluates to true, then code within that
branch (i.e. the immediately-following code that is wrapped in curly braces)
is executed. Otherwise, the code within the else branch is executed.

Conditionals
if (count > 10) {
println("I have the answer.")
} else {a
println("The answer is close.")
}

If-else Ladder
if (count == 42) {
println("I have the answer.")
} else if (count > 35) {
println("The answer is close.")
} else {
println("The answer eludes me.")
}

If-else Ladder
val answerString: String = if (count == 42) {
"I have the answer."
} else if (count > 35) {
"The answer is close."
} else {
"The answer eludes me."
}

When Keyword
val answerString = when {
count == 42 -> "I have the answer."
count > 35 -> "The answer is close."
else -> "The answer eludes me."
}
// “when” keyword is used when the
complexity of Conditional statements
increases.

Loops:
for loop
The for loop iterates through anything
that provides an iterator.
for (item in collection) {
print(item)
}

Loops:
While loops
while and do-while loops execute their
body continuously while their
condition is satisfied. The difference
between them is the condition
checking time:
// while loop
while (x > 0) {
x--
}
// do-while loop
do {
x++
} while (x<10)

Jump Statements
Kotlin has three structural jump expressions:
return by default returns from the nearest
enclosing function or anonymous function.
break terminates the nearest enclosing loop.
continue proceeds to the next step of the
nearest enclosing loop.

Filter
fun main() {
val list = listOf(1,2,3,4,5)
var selecteditems = list.filter ({
it < 4
}).forEach({
println(it)
})
}
When filter() function is called with a predicate, it returns the
collection elements that match the predicate.

Map
fun main() {
val list = listOf(1,2,3,4,5)
var selecteditems = list.map ({
it * it
}).forEach({
println(it)
})
}
when it comes to transforming the elements in the list, Map plays a
vital role in that. Suppose we want to convert each element in the list
into the square of themselves:

Let
fun main() {
var str = "Hello World"
str.let {
println("$it!!")
}
println(str)
}
Kotlin let is a scoping function wherein the variables declared inside
the expression cannot be used outside.
fun main() {
var myName: String? = null
myName?.let {
println(myName)
}
}

So What’s Next…

Let’s Create Our First
Android App

Thank You

Compose Camp

More Related Content

Similar to Compose Camp

Recently uploaded

Compose Camp