Kotlin

Kotlin ORM Framework: New Release

If you're looking for a robust, efficient Object-Relational Mapping (ORM) framework for your Kotlin applications, then you're in luck! In this Kotlin tutorial, we'll introduce you to a brand-new ORM Framework specially designed for Kotlin. This new framework simplifies database interaction by transforming the database table into a Kotlin object. Through this tutorial, you'll get hands-on experience with several features and optimizations that this framework provides. You'll learn how to create database tables, perform CRUD (Create, Read, Update, Delete) operations on data, and many other exciting capabilities of this powerful framework. This Kotlin ORM Framework caters to the developer's every need, from making database interaction easier to improving your application's performance. So, what are you waiting for? Watch this Kotlin tutorial now and bring your Kotlin applications to the next level with this powerful new ORM Framework.

If you have an aversion to new frameworks, don't even read this. For other kind readers, please note that here I'm going to present a proposal for an API for modeling database queries in a declarative style with strong Kotlin type checking primarily. Only some classes around entities are implemented; the database connection is missing for now. In the project, I tried to evaluate my experience and vision so far. However, not all ideas presented in this paper are completely new. Some of them I drew from the Ujorm framework, and the entity concept was inspired by the Ktorm framework. But the code is new. The prototype results from a mosaic that has been slowly pieced together and has now taken a form that is hopefully worth presenting.

If you are not discouraged by the introduction, I will skip the general talk about ORM and let you get to the code samples. The demonstration examples use two relational database tables. This is an employee/department (unspecified organization) relationship where each employee may (or may not) have a supervisor. Both tables are described by entities from the following class diagram:

Suppose we want to create a report containing the unique employee number, the employee's name, the department name, and the supervisor's name (if any). We are only interested in departments with a positive identifier and a department name starting with the letter "D." We want to sort the report by department name (descending) and then by employee name (ascending). How could a query (SELECT) based on these entities look in the presented API?

val employees: Employees = MyDatabase.employees // Employee metamodel
val departments: Departments = MyDatabase.departments // Department metamodel

val result: List<Employee> = MyDatabase.select(
    employees.id,
    employees.name,
    employees.department + departments.name, // DB relation by the inner join
    employees.superior + employees.name) // DB relation by the left outer join
.where((employees.department + departments.id GE 1)
    AND (employees.department + departments.name STARTS "D"))
.orderBy(
    employees.department + departments.name ASCENDING false,
    employees.name ASCENDING true)
.toList()

The use of a DSL in a database query probably doesn't surprise anyone today. However, the chaining of the entity attribute model (hereafter, property-descriptor) is worthy of attention. Combining them creates a new composite property descriptor that implements the same interface as its atomic parts. The query filter (WHERE) is described by an object constructed from elementary conditions into a single binary tree.  Composite property descriptors provide information from which SQL query sessions between database tables are also derived. This approach can cover perhaps the most common SQL queries, including recursive queries. But certainly not all of them. For the remaining ones, an alternative solution must be used. A rough design is in the project tests.

Let's focus next on the employee entity:

@Entity
interface Employee {
    var id: Int
    var name: String
    var higherEducation: Boolean
    var contractDay: LocalDate
    var department: Department
    var superior: Employee?
}

Entity is an interface with no other dependencies. The advantage is that the interface can get by (in ORM) without binary code modification. However, to get the object, you must use a factory method that supplies the implementation. An alternative would be to extend some generic class (provided by the framework), which I found more invasive. The metamodel pair object provides the factory method for creating new objects.

Each entity here needs a metamodel that contains information about its type and attributes that provides some services. The attributes of the metamodel are the property mentioned above descriptors of the pair entities. Note that the same property() method is used to create the property descriptors it doesn't matter if it is a session description (an attribute on another entity). The only exception is where the attribute (entity) type accepts NULL. The positive news is that the compiler will report the misuse (of the shorter method name) at compile time. An example of the employee entity metamodel is attached:

open class Employees : EntityModel<Employee>(Employee::class) {
    val id = property { it.id }
    val name = property { it.name }
    val higherEducation = property { it.higherEducation }
    val contractDay = property { it.contractDay }
    val department = property { it.department }
    val superior = propertyNullable { it.superior }
}

Annotations will declare the specific properties of the columns (database tables) on the entities so that the metamodel classes can be generated once according to their entity. The entity data is stored (internally) in an object array. The advantage is fewer memory requirements compared to an implementation based on the HashMap class.

The next example demonstrates the creation of new objects and their storage in the database (INSERT).

val development: Department = MyDatabase.departments.new {
    name = "Development"
    created = LocalDate.of(2020, 10, 1)
}
val lucy: Employee = MyDatabase.employees.new {
    name = "Lucy"
    contractDay = LocalDate.of(2022, 1, 1)
    superior = null
    department = development
}
val joe: Employee = MyDatabase.employees.new {
    name = "Joe"
    contractDay = LocalDate.of(2022, 2, 1)
    superior = lucy
    department = development
}
MyDatabase.save(development, lucy, joe)

The MyDatabase class (which provides the metamodel) is the only one here (the singleton design pattern). Still, it can generally be any object our application context provides (for example). If we wanted to use a service (cloning an entity object, for example), we could extend (that provider) with the AbstractEntityProvider class and use its resources. An example of the recommended registration procedure (metamodel classes), along with other examples, can be found in the project tests.

Conditions

A condition (or also a criterion) is an object we encountered when presenting a SELECT statement. However, you can also use a condition on its own, for example, to validate entity values or filter collections. If the library provided support for serializing it to JSON text format (and back), the range of uses would probably be even more expansive. To build the following conditions, we start from the metamodel already stored in the employees variable.

val crn1 = employees.name EQ "Lucy"
val crn2 = employees.id GT 1
val crn3 = (employees.department + departments.id) LT 99
val crn4 = crn1 OR (crn2 AND crn3)
val crn5 = crn1.not() OR (crn2 AND crn3)

If we have an employee object in the employee variable, the employee criterion can be tested with the following code:

expect(crn4(employee)).equals(true)  // Valid employee
expect(crn5(employee)).equals(false) // Invalid employee

On the first line, the employee met the criterion; on the second line, it did not. If needed (during debugging or logging), the content of the conditions can be visualized in the text; examples are attached:

expect(crn1.toString())
    .toEqual("""Employee: name EQ "Lucy"""")
expect(crn2.toString())
    .toEqual("""Employee: id GT 1""")
expect(crn3.toString())
    .toEqual("""Employee: department.id LT 99""")
expect(crn4.toString())
    .toEqual("""Employee: (name EQ "Lucy") OR (id GT 1) AND (department.id LT 99)""")
expect(crn5.toString())
    .toEqual("""Employee: (NOT (name EQ "Lucy")) OR (id GT 1) AND (department.id LT 99)""")

Other Interesting Things

The property descriptor may not only be used to model SQL queries but can also participate in reading and writing values to the object. The simplest way is to extend the entity interface with the PropertyAccessor interface. If we have an employee object, code can be used to read it:

val id: Int = employee[employees.id]
val name: String = employee[employees.name]
val contractDay: LocalDate = employee[employees.contractDay]
val department: Department = employee[employees.department]
val superior: Employee? = employee[employees.superior]
val departmentName: String = employee[employees.department + departments.name]

The explicit declaration of variable data types is for presentation purposes only, but in practice, they are redundant and can be removed. Writing variables to an object is similar:

employee[employees.id] = id
employee[employees.name] = name
employee[employees.contractDay] = contractDay
employee[employees.department] = department
employee[employees.superior] = superior
employee[employees.department + departments.name] = departmentName

Please note that reading and writing values are done without overriding also for NULLABLE values. Another interesting feature is the support for reading and writing values using composite property descriptors. Just for the sake of argument, I assure you that for normal use of the object, it will be more convenient to use the standard entity API declared by the interface.

The sample above copies its attributes to variables and back. If we wanted to clone an object, we could use the following construct (shallow copy):

val target: Employee = MyDatabase.utils().clone(source)

No reflection methods are called during data copying, which is allowed by the class architecture used. More functional usage examples can be found in the project tests on GitHub.

Why?

Why was this project created? In the beginning, it was just an effort to learn the basics of Kotlin. Gradually a pile of disorganized notes in the form of source code was created, and it was only a matter of time before I came across language resources that would also lead to a simplified Ujorm framework API. Finding ready-made ORM libraries in Kotlin made me happy. However, of the two popular ones, I couldn't pick one that suited me better. I missed interesting features of one with the other and vice versa. In some places, I found the API not intuitive enough to use; in others, I ran into complications with database table recursion. A common handicap was (for my taste) the increased error rate when manually building the entity metamodel. Here one can certainly counter that entities can be generated from database tables. In the end, I organized my original notes into a project, cleaned up the code, and added this article. That is perhaps all that is relevant.

Conclusion

I like the integration with the core of a ready-made ORM framework; probably the fastest would be the integration with Ujorm. However, I am aware of the risks associated with any integration, and I can't rule out that this project won't eventually find any real use in the ORM field. The prototype is freely available under the Apache Commons 2 license. Thank you for your constructive comments.

Article source: https://dzone.com

#kotlin 

A Port Of Kotlin-stdlib for Dart/Flutter Projects

This project is a port of Kotlin's Kotlin Standard library for Dart/Flutter projects. It's a useful addition to dart:core and includes collections (KtList, KtMap, KtSet) as well as other packages which can improve every Dart/Flutter app.

dependencies: 
  kt_dart: ^1.1.0

import 'package:kt_dart/kt.dart';

Motivation

Dart's dart:core package provides basic building blocks. But sometimes they are too low level and not as straightforward as Kotlin's kotlin-stdlib.

Here are a few examples of what this project offers: (click to expand)

Immutable collections by default

Deep equals

Common methods

KtList

KtList is a read-only list of elements. It is immutable because it doesn't offer mutation methods such as remove or add. Use KtMutableMap if you want to use a mutable list.

To create a KtList/KtMutableList use the KtList.of constructor or convert an existing Dart List to a KtList with the list.toImmutableList() extension.

Create a KtList

// Create a KtList from scratch
final beatles = KtList.of("John", "Paul", "George", "Ringo");

// Convert a existing List to KtList
final abba = ["Agnetha", "Björn", "Benny", "Anni-Frid"];
final immutableAbba = abba.toImmutableList();

Create a KtMutableList

KtList is immutable by default, which means it doesn't offer methods like add or remove. To create mutable list with kt_dart use the KtMutableList constructor.

// Create a KtMutableList from scratch
final beatles = KtMutableList.of("John", "Paul", "George", "Ringo");
beatles.removeAt(0);
print(beatles); // [Paul, George, Ringo]

Mutable/Immutable conversion

Conversions between KtList and KtMutableList can be done with KtList.toMutableList() and KtMutableList.toList();

final beatles = KtList.of("John", "Paul", "George", "Ringo");
final mutable = beatles.toMutableList();
mutable.removeAt(0);
print(mutable); // [Paul, George, Ringo]
print(beatles); // [John, Paul, George, Ringo]

for loop

kt_dart collections do not implement Iterable. It is therefore not possible to directly iterate over the entries of a KtList.

All kt_dart collections offer a .iter property which exposes a Dart Iterable. For-loops therefore don't look much different.

final beatles = KtList.of("John", "Paul", "George", "Ringo");
for (final member in beatles.iter) {
  print(member);
}

Yes, alternatively you could use .asList() instead which returns a Dart List.

Kotlin syntax

Kotlin users might be more familiar with the listOf() and mutableListOf() functions. Use them if you like but keep in mind that the dart community is much more used to use constructors instead of top-level functions.

final beatles = listOf("John", "Paul", "George", "Ringo");
final abba = mutableListOf("Agnetha", "Björn", "Benny", "Anni-Frid");

KtSet

A KtSet is a unordered collection of elements without duplicates.

Creating a KtSet/KtMutableSet is very similar to the KtList API.

// Create a KtSet from scratch
final beatles = KtSet.of("John", "Paul", "George", "Ringo");

// Convert a existing Set to KtSet
final abba = {"Agnetha", "Björn", "Benny", "Anni-Frid"};
final immutableAbba = abba.toImmutableSet();

KtMap

To create a KtMap/KtMutableMap start with Dart Map and then convert it to a KtMap with either:

• pokemon.toImmutableMap(): KtMap (since Dart 2.7)
• KtMap.from(pokemon): KtMap
• pokemon.kt: KtMutableMap (since Dart 2.7)
• KtMutableMap.from(pokemon): KtMutableMap

// immutable
final pokemon = {
  1: "Bulbasaur",
  2: "Ivysaur",
  3: "Stegosaur",
}.toImmutableMap();

final newPokemon = KtMap.from({
  152: "Chikorita",
  153: "Bayleef",
  154: "Meganium",
});

// mutable
final mutablePokemon = {
  1: "Bulbasaur",
  2: "Ivysaur",
  3: "Stegosaur",
}.kt;

final newMutablePokemon = KtMutableMap.from({
  152: "Chikorita",
  153: "Bayleef",
  154: "Meganium",
});

KtHashMap and KtLinkedMap

You may want to use a specific Map implementation. kt_dart offers:

• KtLinkedMap - based on Darts LinkedHashMap where the insertion order of keys is remembered and keys are iterated in the order they were inserted into the map
• KtHashMap - based on Darts HashMap where keys of a HashMap must have consistent [Object.==] and [Object.hashCode] implementations. Iterating the map's keys, values or entries (through [forEach]) may happen in any order.

KtPair, KtTriple

kt_dart offer two types of tuples, KtPair with two elements and KtTriple with three elements. They are used by some collection APIs and prevent a 3rd party dependency.

final beatles = KtList.of("John", "Paul", "George", "Ringo");
final partitions = beatles.partition((it) => it.contains("n"));
print(partitions.first); // [John, Ringo]
print(partitions.second); // [Paul, George]

There won't be a KtQuadruple or TupleN in this library. If you want to use tuples heavily in you application consider using the tuple package. Better, use freezed to generated data classes which makes for a much better API.

Annotations

@nullable

Kotlin already has Non-Nullable types, something which is coming to Dart soon™. kt_dart already makes use of Non-Nullable Types and never returns null unless a method is annotated with @nullable.

https://github.com/passsy/kt.dart/blob/490a3b205ffef27d9865d6018381a4168119e69f/lib/src/collection/kt_map.dart#L51-L53

There isn't any tooling which will warn you about the wrong usage but at least it's documented. And once nnbd lands in Dart it will be fairly easy to convert.

@nonNull

This annotation annotates methods which never return null. Although this is the default in kt_dart, is makes it very obvious for methods which sometimes return null in other languages.

@experimental

A method/class annotated with @experimental marks the method/class as experimental feature. Experimental APIs can be changed or removed at any time.

License

Copyright 2019 Pascal Welsch

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

Use this package as a library

Depend on it

Run this command:

With Dart:

 $ dart pub add kt_dart

With Flutter:

 $ flutter pub add kt_dart

This will add a line like this to your package's pubspec.yaml (and run an implicit dart pub get):

dependencies:
  kt_dart: ^1.1.0

Alternatively, your editor might support dart pub get or flutter pub get. Check the docs for your editor to learn more.

Import it

Now in your Dart code, you can use:

import 'package:kt_dart/annotation.dart';
import 'package:kt_dart/collection.dart';
import 'package:kt_dart/exception.dart';
import 'package:kt_dart/kt.dart';
import 'package:kt_dart/standard.dart';

example/main.dart

// ignore_for_file: avoid_print
import "package:kt_dart/kt.dart";

void main() {
  /// Lists
  final mapped = listOf(1, 2, 3, 4).map((it) => ">$it<");
  print(mapped); // [>1<, >2<, >3<, >4<]

  final flatMapped = listOf(1, 2, 3, 4).flatMap((it) => listOf(it * 2, it * 3));
  print(flatMapped); // [2, 3, 4, 6, 6, 9, 8, 12]

  final filtered = flatMapped.filter((it) => it % 3 == 0);
  print(filtered); // [3, 6, 6, 9, 12]

  final distinct = listFrom([1, 2, 3, 1, 2, 3]).distinct();
  print(distinct); //[1, 2, 3]

  /// Better equals
  final kListEquals = listOf(12, 9, 6, 3) == listOf(12, 9, 6, 3);
  print(kListEquals); // true

  final dartListEquals = [12, 9, 6, 3] == [12, 9, 6, 3];
  print(dartListEquals); // false

  final kMapEquals = mapFrom({1: "Bulbasaur", 2: "Ivysaur"}) ==
      mapFrom({1: "Bulbasaur", 2: "Ivysaur"});
  print(kMapEquals); // true

  final dartMapEquals =
      {1: "Bulbasaur", 2: "Ivysaur"} == {1: "Bulbasaur", 2: "Ivysaur"};
  print(dartMapEquals); // false

  /// Sets
  print(setOf(1, 2, 3, 1, 2, 3)); // [1, 2, 3]

  /// Maps
  final pokemon = mutableMapFrom({
    1: "Bulbasaur",
    2: "Ivysaur",
  });
  pokemon[1] = "Ditto";
  print(pokemon); // {1=Ditto, 2=Ivysaur}

  /// Tons of useful operators which *should* be part of the dart std lib
  final numbers = listOf(1, 2, 3, 4);
  print(numbers.sum()); // 10

  final numbers5 = listOf(1, 2, 3, 4).sortedDescending();
  print(numbers5); // [4, 3, 2, 1]

  final beatles = setOf("John", "Paul", "George", "Ringo");
  print(beatles); // [John, Paul, George, Ringo]
  print(beatles.joinToString(
      separator: "/",
      transform: (it) => it.toUpperCase())); // JOHN/PAUL/GEORGE/RINGO

  final grouped = beatles.groupBy((it) => it.length);
  print(grouped); // {4=[John, Paul], 6=[George], 5=[Ringo]}
}

Download details:

Author: pascalwelsch.com

Source: https://github.com/passsy/kt.dart

#flutter #dart #kotlin #intellij-idea #ios #android #web #web-development 

Best Technology Stacks For Mobile App Development

No matter what #mobileappdevelopment process you are planning to follow, it will never turn fruitful until you get together a set of robust #technology stack.

Defining the #technologystack at an early stage helps entrepreneurs achieve their ultimate business objectives much more easily.

Wondering what are the top tech stacks that are popularly chosen to create a top-quality app?

Check out the full list below and choose the best mobile app tech stack for your next app - https://lnkd.in/dcPpwrg

#technologynews #technology #newtechnologies #java #reactnative #crossplatformappdevelopment #hybridappdevelopment #hybridapps #appdevelopment #mobileappdevelopmentservices #xamarin #swift #ionic #kotlin #enterprenuer #android #ios #java #javascript #objectivec

Android App Development using Jetpack Compose in Kotlin

Kotlin Android App Development using Jetpack Compose Crash Course (Hindi)
 

00:00:00 Pre-requisites
00:03:12 Introduction to Jetpack Compose
00:04:05 Create Jetpack Compose Project
00:06:54 Introduction to Android Studio
00:14:16 Text
00:16:40 Create Composable Function
00:18:02 Composable Function with Parameter
00:19:28 Elements are in Stack
00:22:01 List and Loop inside Composable
00:23:58 Styling Text
00:27:44 Use Custom Font or Google Font
00:33:31 Align Text
00:34:41 Modifier
00:37:12 Repeat Text
00:39:17 Selectable Text
00:42:35 Disable Selection Text
00:44:01 Row
00:45:53 Center Row Elements
00:50:10 Scrollable Row
00:53:31 Column
00:55:22 Center Column Elements
00:59:01 Scrollable Column
01:01:48 Lazy Row
01:08:10 Center Lazy Row Items
01:11:40 Lazy Column
01:12:55 Center Lazy Column Items
01:14:55 Box
01:23:30 Using Material Design
01:27:38 Using Asset Images
01:33:10 Using Network Image
01:37:05 Using Icon
01:39:25 Card
01:43:24 Spacer
01:44:00 Find Properties
01:44:42 Stateful Composable
01:52:09 State Hoisting
01:56:04 Buttons
02:04:46 Text Field
02:14:35 Registration Form

Source Code: https://github.com/geekyshow1/KotlinAndroidCrashC 

#kotlin #jetpack 

How to Getting Started with Realm & Kotlin

In this hands on session, Mohit Sharma, Developer Advocate with MongoDB will walk through getting started with Realm & Kotlin

#realm #kotlin #mongodb 

How to Create a Paint Application in Android with Kotlin

We all have once used MS-Paint in our childhood but have you ever thought about how these functionalities were brought to life?  No worries, here in this video, we're going to discuss how to create a Paint Application in Android. We'll be using Kotlin language to create this Paint application project. So, let's get started now.

#android ​#project #kotlin ​#androidapp #androidstudio #drawingapp

Find Out StartActivityforResult Depreciated Solution | Kotlin

In this video we will do:
1) Learn to use the alternative of startActivityForResult.
2) Use for any Intent e.g. Gallery, Camera, File, etc that previously uses startActivityForResult().
3) Recover

Check For Java: https://youtu.be/tUCfIK908i8

Chapters:
0:00 Create, Setup Project 
0:33  UI Design 
02:57  Coding/Implementation
09:34 Testing

#java #kotlin 

Kotlin Vs Java: The 12 Differences You Should Know

Do you prefer Kotlin or Java for Android development? This article seeks to explain the twelve main differences between both programming languages. Afterward, we discuss whether Kotlin is or not better than Java and highlight the main reasons.

1. Null Safety

2. Extension Functions

3. Code

4. Coroutines Support

5. Data Classes

6. Smart Casts

…

#Java #kotlin 

How to Use WorkManager in Android Kotlin

This video shows how to use WorkManager in Android Kotlin. We also write tests for our WorkManager

WorkManager supports:
- One-off and periodic tasks
- Constraints, such as network availability
- Chaining tasks, parallel or sequentially
- Observable task state for display in UI
- Customise threading strategy

Using WorkManager in Android | Schedule Tasks | Test WorkManager

0:08 Demo of OneTimeWorkRequest
1:28 Demo of PeriodicWorkRequest
1:55 Step 1 : Setup Gradle dependencies
2:05 Step 2 : Manifest and Application
2:42 Step 3.1 : Create OnDemandBackupWorker
3:52 Step 3.2 : Create FileWorker
5:00 Step 4 : Create ViewModel
7:04 Step 5 : Change in MainActivity
8:05 Step 6 : Create PeriodicBackupWorker
8:40 Step 7 : Change Application Class
9:13 Step 8 : Testing OnDemandBackupWorker
10:11 Step 9 : Testing PeriodicBackupWorker

Source Code: https://github.com/AseemWangoo/hands_on_kotlin

#android #kotlin

Social Network with Ktor

In my Twitch live streams we will build a social network together. You will learn the whole process of building an app.
You will...
... see me struggle and how I solve my problems
... get quick answers to your questions
... impact the outcome of the app
... learn A LOT about the whole app development process

#ktor #developer #kotlin 

Top 10 Programming Languages to Learn In 2022

Top 10 Programming Languages to Learn In 2022

10. Ruby
9. Go
8. PHP
7. Rust
6. C++
5. C#
4. Kotlin
3. Typescript
2. Python
1. JavaScript

#javascript #python #typescript #kotlin #csharp #cplusplus #rust #php #go #ruby #programming 

Kotlin : Named Arguments | Parameters

Kotlin : Named Arguments | Parameters | android coding

More Interesting tutorials :
Flutter Video Player : https://youtu.be/dXxe7E6WPUM
Flutter Fetch Location : https://youtu.be/4E3saOmv7ow
Flutter Grant Permission : https://youtu.be/jP0U03OqVW4

#parameter #argument #kotlin

Inline Functions with Added Subtitles in Kotlin

Kotlin : Inline Functions | Added Subtitles | android coding
Kotlin Complete Course:
Kotlin Introduction : https://youtu.be/2_EXYeKVX3g
Kotlin Variables & Data Types : https://youtu.be/bevfj0pFH6Q
Kotlin If-Conditions : https://youtu.be/8r0TMiKLwGo
Kotlin When Condition (Switch) : https://youtu.be/oQ3rXxU2bK4
Kotlin For Loop : https://youtu.be/10uMCFiUDNU
Kotlin While & Do-While Loop : https://youtu.be/nXStQ8WFCT0

#kotlin #subtitle #function

Kotlin : High-order functions and lambdas

Kotlin : High-order functions and lambdas | Added Subtitles | android coding
More Interesting tutorials :
Flutter Video Player : https://youtu.be/dXxe7E6WPUM
Flutter Fetch Location : https://youtu.be/4E3saOmv7ow
Flutter Grant Permission : https://youtu.be/jP0U03OqVW4

#kotlin #high-order #lambdas #function

Non-Null assertion usage and examples in Kotlin

Kotlin : Non-Null assertion usage & example | Added Subtitles | android coding

Kotlin Complete Course:
Kotlin Introduction : https://youtu.be/2_EXYeKVX3g
Kotlin Variables & Data Types : https://youtu.be/bevfj0pFH6Q
Kotlin If-Conditions : https://youtu.be/8r0TMiKLwGo
Kotlin When Condition (Switch) : https://youtu.be/oQ3rXxU2bK4
Kotlin For Loop : https://youtu.be/10uMCFiUDNU
Kotlin While & Do-While Loop : https://youtu.be/nXStQ8WFCT0

#kotlin #usage #non-null