# Android App Activity.kt
## Logging
```kotlin
Log.i("tag", "logValue") //info log
Log.d("tag", "logValue") //debug log
Log.w("tag", "logValue") //warning log
Log.e("tag", "logValue") //error log
Log.c("tag", "logValue") //critical log
```
## Activity Life Cycle
```kotlin
package com.its.<appname>
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
class MainActivity : AppCompatActivity() {
//entry point of the activity
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.<activity_xml>)
}
override fun onStart() {
}
override fun onResume() {
}
override fun onPause() {
}
override fun onStop() {
}
override fun onRestart() {
}
override fun onDestroy() {
}
}
```
### Passing data between activities
In *laughing* activity:
```kotlin
private fun openActivity() {
//target to open Intent(opener, opened)
val intent = Intent(this, Activity::class.java)
//pass data to launched activity
intent.putExtra("identifier", value)
startActivity(intent) //launch another activity
}
```
In *launched* activity:
```kotlin
val identifier = intent.get<Type>Extra("identifier")
```
## Hooks
### Resources Hooks
```kotlin
R.<resourceType>.<resourceName> //access to resource
ContextCompat.getColor(this, colorResource) //extract color from resources
getString(stringResource) //extract string from resources
```
### XML hooks
Changes in xml made in kotlin are applied after the app is drawn thus overwriting instructions in xml.
In `activity.xml`:
```xml
<View
android:id="@+id/<id>"/>
```
in `Activity.kt`:
```kotlin
var element = findViewById(R.id.<id>) //old method
<id>.popery = value //access and modify view contents
```
## Activity Components
### Snackbar
Component derived from material design. If using old API material design dependency must be set in gradle.
In `build.gradle (Module:app)`:
```gradle
dependencies {
implementation 'com.google.android.material:material:<sem_ver>'
}
```
In `Activity.kt`:
```kotlin
import com.google.android.material.snackbar.Snackbar
Snackbar
.make(activityID, message, Snackbar.TIME_ALIVE) //create snackbar
.setAction("Button Name", { action }) //add button to snackbar
.show()
```
## Opening External Content
### Opening URLs
```kotlin
val url = "https://www.google.com"
val intent = Intent(Intent.ACTION_VIEW)
intent.setData(Uri.parse(url))
startActivity(intent)
```
### Sharing Content
```kotlin
val intent = Intent(Intent.ACTION_SEND)
intent.setType("text/plain") //specifying shared content type
intent.putExtra(Intent.EXTRA_MAIL, "mail@address") //open mail client and pre-compile field if share w/ mail
intent.putExtra(Intent.EXTRA_SUBJECT, "subject")
intent.putExtra(Intent.EXTRA_TEXT, "text") //necessary since type is text
startActivity(Intent.startChooser(intent, "chooser title")) //let user choose the share app
```
### App Google Maps
[Documentation](https://developers.google.com/maps/documentation/urls/android-intents)
```kotlin
val uri = Uri.parse("geo: <coordinates>")
val intent = Intent(Intent.ACTION_VIEW, uri)
intent.setPackage("com.google.android.apps.maps") //app to be opened
startActivity(intent)
```
### Make a call (wait for user)
Preset phone number for the call, user needs to press call button to initiate dialing.
```kotlin
fun call() {
val intent = Intent(Intent.ACTION_DIAL)
intent.setData(Uri.parse("tel: <phone number>"))
startActivity(intent)
}
```
### Make a call (directly)
In `AndroidManifest.xml`:
```xml
<uses-permission android:name="android.permission.CALL_PHONE" />
```
```kotlin
//https://developer.android.com/training/permissions/requesting
//intercept OS response to permission popup
override fun onRequestPermissionResult(requestCode: Int, permissions: Array<out String>, grantResults: IntArray) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults)
}
fun checkCallPermission() {
//check if permission to make a call has been granted
if (ContextCompact.checkSelfPermission(context!!, android.Manifest.permission.CALL_PHONE) != PackageManager.PERMISSION_GRANTED) {
// if permission has not been granted request it (opens OS popup, no listener available)
// request code needs to be specific for the permission
ActivityCompat.requestPermissions(context!!, arrayOf(android.Manifest.permission.CALL_PHONE), requestCode)
} else {
call() //if permission has been already given
}
}
@SuppressLint("MissingPermission") // suppress warning of unhandled permission (handled in checkCallPermission)
fun call() {
val intent = Intent(Intent.ACTION_DIAL, Uri.parse("tel: <phone number>"))
startActivity(intent)
}
```
## Lists (with RecyclerView)
A [LayoutManager][1] is responsible for measuring and positioning item views within a `RecyclerView` as well as determining the policy for when to recycle item views that are no longer visible to the user.
By changing the `LayoutManager` a `RecyclerView` can be used to implement a standard vertically *scrolling list*, a *uniform grid*, *staggered grids*, *horizontally scrolling collections* and more.
Several stock layout managers are provided for general use.
[Adapters][2] provide a binding from an app-specific data set to views that are displayed within a `RecyclerView`.
[1]:https://developer.android.com/reference/kotlin/androidx/recyclerview/widget/RecyclerView.LayoutManager
[2]:https://developer.android.com/reference/kotlin/androidx/recyclerview/widget/RecyclerView.Adapter
```kotlin
var array: ArrayList<T>? = null //create ArrayList of elements to be displayed
var adapter: RecyclerViewItemAdapter? = null //create adapter to draw the list in the Activity
array.add(item) //add item to ArrayList
// create LayoutManager for the recyclerView
val layoutManager = <ViewGroup>LayoutManager(context, <ViewGroup>LayoutManager.VERTICAL, reverseLayout: Bool)
recycleView.LayoutManager = layoutManager // assign LayoutManager for the recyclerView
// handle adapter var containing null value
if (array != null) {
adapter = RecyclerViewItemAdapter(array!!) // valorize adapter with a adapter object
recyclerView.adapter = adapter // assign adapter to the recyclerView
}
// add or remove item
// tell the adapter that something is changed
adapter?.notifyDataSetChanged()
```
## WebView
[WebView Docs](https://developerandroid.com/reference/android/webkit/WebView)
```kotlin
webView.webViewClient = object : WebViewClient() {
// avoid opening browsed by default, open webview instead
override fun shouldOverrideUrlLoading(view: WebView?, url: String?): Boolean {
view?.loadUrl(url) // handle every url
return true
}
override fun shouldOverrideUrlLoading(view: WebView?, url: String?): Boolean {
// stay in WebView until website changes
if (Uri.parse(url).host == "www.website.domain") {
return false
}
Intent(Intent.ACTION_VIEW, Uri.parse(url).apply){
startActivity(this) // open browser/app when the website changes to external URL
}
return true
}
webView.settings.javaScriptEnabled = true // enable javascript
webView.addJavaScriptInterface(webAppInterface(this, "Android")) // create bridge between js on website an app
// if in webView use android back butto to go to previous webpage (if possible)
override fun onKeyDown(keyCode: Int, event: KeyEvent?) :Boolean {
if (keyCode == KeyEvent.KEYCODE_BACK && webVew,canGoBack()) { // if previous url exists & back button pressed
webView.goBack() // go to previous URL
return true
}
}
}
```
## Web Requests (Using Volley)
[Volley Docs](https://developer.android.com/training/volley)
### Import & Permissions
Import in `build.gradle`:
```kotlin
implementation 'com.android.volley:volley:1.1.1'
```
Permissions in `AndroidManifest.xml`:
```xml
<uses-permission android:name="android.permission.INTERNET" />
```
### Make the request
Subsequent requests should be delayed to avoid allowing the user to make too frequent requests.
```kotlin
private lateinit var queue: RequestQueue
override fun onCreate(savedInstanceState: Bundle?){
queue = Volley.newRequestQueue(context)
}
// response is a String
private fun simpleRequest() {
var url = "www.website.domain"
var stringRequest = StringRequest(Request.Method.GET, url, Response.Listener<String> {
Log.d()
},
Response.ErrorListener{
Log.e()
})
stringRequest.TAG = "TAG" // assign a tag to the request
queue.add(stringRequest) // add request to the queue
}
// response is JSON Object
private fun getJsonObjectRequest(){
// GET -> jsonRequest = null
// POST -> jsonRequest = JsonObject
var stringRequest = JsonObjectRequest(Request.Method.GET, url, jsonRequest, Response.Listener<String> {
Log.d()
// read end use JSON
},
Response.ErrorListener{
Log.e()
})
queue.add(stringRequest) // add request to the queue
}
// response is array of JSON objects
private fun getJSONArrayRequest(){
// GET -> jsonRequest = null
// POST -> jsonRequest = JsonObject
var stringRequest = JsonArrayRequest(Request.Method.GET, url, jsonRequest, Response.Listener<String> {
Log.d()
// read end use JSON
},
Response.ErrorListener{
Log.e()
})
queue.add(stringRequest) // add request to the queue
}
override fun onStop() {
super.onStop()
queue?.cancelAll("TAG") // delete all request with a particular tag when the activity is closed (avoid crash)
}
```
### Parse JSON Request
```kotlin
Response.Listener { response ->
var value = response.getSting("key")
}
```
## Data Persistance
### Singleton
Object instantiated during app init and is destroyed only on app closing. It can be used for data persistance since is not affected by the destruction of an activity.
```kotlin
// Context: Interface to global information about an application environment.
class Singleton constructor(context: Context) {
companion object {
@Volatile
private var INSTANCE: Singleton? = null
// synchronized makes sure that all instances of the singleton are actually the only existing one
fun getInstance(context: Context) = INSTANCE ?: synchronized(this) {
INSTANCE ?: Singleton(context).also {
INSTANCE = it
}
}
}
}
```
### SharedPreferences
[SharedPreferences Docs](https://developer.android.com/training/data-storage/shared-preferences)
**Get a handle to shared preferences**:
- `getSharedPreferences()` — Use this if you need multiple shared preference files identified by name, which you specify with the first parameter. You can call this from any Context in your app.
- `getPreferences()` — Use this from an Activity if you need to use only one shared preference file for the activity. Because this retrieves a default shared preference file that belongs to the activity, you don't need to supply a name.
```kotlin
val sharedPref = activity?.getSharedPreferences( getString(R.string.preference_file_key), Context.MODE_PRIVATE )
val sharedPref = activity?.getPreferences(Context.MODE_PRIVATE)
```
**Write to shared preferences**:
To write to a shared preferences file, create a `SharedPreferences.Editor` by calling `edit()` on your SharedPreferences.
Pass the keys and values to write with methods such as `putInt()` and `putString()`. Then call `apply()` or `commit()` to save the changes.
```kotlin
val sharedPref = activity?.getPreferences(Context.MODE_PRIVATE) ?: return
with (sharedPref.edit()) {
putInt(getString(R.string.key), value)
commit() // or apply()
}
```
`apply()` changes the in-memory `SharedPreferences` object immediately but writes the updates to disk *asynchronously*.
Alternatively, use `commit()` to write the data to disk *synchronously*. But because *commit()* is synchronous, avoid calling it from your main thread because it could pause the UI rendering.
**Read from shared preferences**:
To retrieve values from a shared preferences file, call methods such as getInt() and getString(), providing the key for the wanted value, and optionally a default value to return if the key isn't present.
```kotlin
val sharedPref = activity?.getPreferences(Context.MODE_PRIVATE) ?: return
val defaultValue = resources.getInteger(R.integer.default_value_key)
val value = sharedPref.getInt(getString(R.string.key), defaultValue)
```