Compose Camp 2.pdf

This work is licensed under the Apache 2.0 License

Day 1 of Compose Camp
● Kotlin Basics
● Installing Android studio
● Build a Basic Layout

Maruthi R
GDSC LEAD SIT
Camp leaders
Abhishek S
Compose Camp Facilitator

What is Compose Camp?
Community-organized events focused around
how to build Android apps using Jetpack
Compose, where attendees get hands-on
coding experience with Compose.

Less code
Do more with less code
And avoid entire classes
Of bugs. Code is simpler,
easier to maintain
Why Jetpack Compose
Intuitive
Just describe your UI,
and compose takes care
of the rest. As app state
changes, your UI
automatically updates
Accelerates
Development
Compatible with all your
existing code so you can
adopt when and where
you want iterate fast with
live previews and full
Android Studio support
Powerful
Create beautiful apps
with direct access to the
Android platform APIs
and built-in support for
Material Design, Dark
Theme, animations, and
more.

● Basic computer literacy
● Basic math skills
● (Optional) Android device & USB cable
Prerequisites

● Set up Android Studio on your computer
● Learn the basics of the Kotlin programming language
● Learn Jetpack Compose
● Learn to create Android App
Compose Camp Learning Objectives

Kotlin
Kotlin is an open-source statically typed
programming language that targets the
JVM, Android, JavaScript and Native.

Jetpack Compose is Android's modern toolkit for building native UI. It
simplifies and accelerates UI development on Android. Quickly bring your
app to life with less code, powerful tools, and intuitive Kotlin APIs.
Jetpack Compose

Ok! Lets get Started

Kotlin Playground
Write and run Kotlin code in
the browser.
https://play.kotlinlang.org/

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

main Function
The main function is the entry
point, or starting point, of the
program.
Start here
fun main() {
println("Hello, world!")
}
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

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 or
parameters.
}

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

Putting it together
fun main() {
// code
}
Output:
Welcome to Compose Camp!

A container for a single piece of data.
Variables

My name is and I am years old
Variables
name age

My name is and I am years old
Variables
Name value: Abhishek
Age value: 19
Output:
My name is Abhishek and
I am 19 years old
Name value: Janet
Age value: 49
Output:
My name is Janet and I
am 49 years old
name age

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.
fun main() {
val name: String = "Abhi"
var age: Int = 19
}

Defining a variable
All variables must have a name.
fun main() {
var age: Int = 19
}

Defining a variable
Data type is the type of data
that the variable holds.
fun main() {
var age: Int = 19
}

Defining a variable
The initial value is the value that
is stored in the variable.
fun main() {
var age: Int = 19
// val name = “Abhi”
// var age = 19
}

Defining a variable
If we want to define a variable
with no initial value.
fun main() {
val name: String
var age: Int
// var age => Error
}

Putting it together
fun main() {
// Define a variable storing name of a person
// Define a variable storing age of a person
// Print Statement and use of ‘$’ operator
}

Putting it together
fun main() {
// Call a function
}
// Define a function
fun firstFunction() {
// Function Body
}

Return Value
We have to mention what has to
be returned by the function by
providing the data type for it.
If a function does not return
anything then it is having ‘Unit’
return type
fun firstFunction() : String {
// Body
return “value”
}

Parameters
We can define various parameters or inputs for the function
fun firstFunction(age : Int): Int{
// body
return age
}
fun main(){
// calling the function
}

Function with multiple
parameters
fun firstFunction(age : Int, name : String){
// body
}
fun main(){
firstFucntion(21, “yourName”)
}

Named arguments
fun firstFunction(age : Int, name : String){
// body
}
fun main(){
firstFunction(name = “YourName”, age = 20)
}
We need to keep in mind the order of parameters while passing the
arguments so we can use named arguments.

Function with default parameters
fun firstFunction(age : Int, name : String = “noName”){
// body
}
fun main(){
firstFucntion(21, “YourName”)
firstFunction(21)
}

Installing Android Studio

Android Studio
Android Studio is the official
Integrated Development Environment
(IDE) for Android app development,
based on IntelliJ IDEA.
Learners will use Android Studio to build their
Android apps using Compose.

Android Studio System Requirements
Source
Computers must meet these system requirements in order to download Android Studio on them.
Windows
64-bit Microsoft® Windows® 8/10
x86_64 CPU architecture; 2nd
generation Intel Core or newer, or
AMD CPU with support for a
Windows Hypervisor
8 GB RAM or more
8 GB of available disk space
minimum (IDE + Android SDK +
Android Emulator)
1280 x 800 minimum screen
resolution
Mac
MacOS® 10.14 (Mojave) or higher
ARM-based chips, or 2nd
generation Intel Core or newer
with support for
Hypervisor.Framework
8 GB RAM or more
Android Emulator)
resolution
Linux
Any 64-bit Linux distribution that
supports Gnome, KDE, or Unity DE;
GNU C Library (glibc) 2.31 or later.
x86_64 CPU architecture; 2nd
generation Intel Core or newer, or
AMD processor with support for
AMD Virtualization (AMD-V) and
SSSE3
8 GB RAM or more
Android Emulator)
resolution
Chrome OS
For information on
recommended devices and
specifications, as well as
Android Emulator support,
visit chromeos.dev.

Download Android Studio
Note: If attendees encounter an issue with Android Studio, help them file a bug report.

Android Studio

Android Studio - Project View

Android Studio - Code View

Android Studio - Design View

Android Studio - Split View

The Android Emulator emulates Android devices on your computer so
that you can test your application on a variety of devices and Android
API levels without needing to have each physical device.
What is an emulator?

Creating an emulator

THANK YOU
for participating in Compose Camp Day 2

Compose Camp 2.pdf

Recommended

Recommended

More Related Content

Similar to Compose Camp 2.pdf

Similar to Compose Camp 2.pdf (20)

Recently uploaded

Recently uploaded (20)

Compose Camp 2.pdf