DEV Community: kururu

Dart basics - part 3

kururu — Sun, 13 Mar 2022 10:31:12 +0000

in the previous topic we learn how to create and invoke a function.

in this topic we are going to learn some advance functions.

** Callback Function**

Callback is basically a function or a method that we pass as an argument into another function or a method to perform an action

Imagine you have a function that return a future value
and you try to invoke it in non-future function then you have to use callback syntax:

Future getMyName()async {
  await Future.delayed(Duration(seconds:5));

  return "Kururu is Beast";
}

you can invoke this function using callbacks way:

getMyName().then((value){
    print(value);
  });

after 5 seconds will print

Kururu is Beast

also the callback function can be use with extension


class Name{
   String name;
  Name(this.name);



}



extension capitalizeName on Name{

  String capitalize(){
      return this.name.toUpperCase();
  }
}

to invoke the function:

  var myName = Name('Kururu');
  var r =myName.capitalize();


      print(r);

Higher Order Functions

higher-order function that can be passed as a parameter .

i find another definition in this post

In dart programming language can accept a function as an argument, this type of functions is called higher order functions.

 String getUser()=> "Kururu";

void printUser(String Function() getUser)
{
    // getting user maybe it's from api like etc.
    String user = getUser();

   // and print the user.
    print(user);
  }

to invoke printUser you have to pass a function that return a string and not accept any parameter which is getUser in our example

 printUser(getUser);

And there are many higher-order functions related to List and String , etc.

*Lambda Expression *

lambda expression is a function without name

to create a lambda function use Function keyword

Function printMyName = (String name) =>name;

to execute this anonymous function:

print(printMyName("Kururu For life"));

it is not clear , right:)

thanks for reading:)

Dart basics - part 2

kururu — Mon, 28 Feb 2022 11:35:47 +0000

in the first post we covered some basics like variable and control structure
in to days lesson we are going to focus on Functions

Functions in Dart

generally , there are two type of functions in dart like other languages:
- function return a value
- function not return any value( void )

function form:
[type] function_name( [variables] ) {
[return ]
}

for example , function accepts two params and show the sum of them:

`
void sumTwoValues(int x, int y){
var sum = x+y;
print(sum);

note: the return type is optional as dart can inferred the type:)

an example of the function with return type , let's create a function the accept a text and return a length of that text

`int textLngthGenerator(Stirng txt){

return txt.length;

to invoke this function:

var text= 'i love Sudan'; var textLength = textLngthGenerator(text); print(textLength);

You noticed that you can use single quotes to represent a string

we stop here , and in the next post will discuss some topics related to functions like:
- higher-order functions
- callback functions
- extension functions

thanks for reading :)

Jetpack Compose Lifecycle

kururu — Thu, 24 Feb 2022 12:03:52 +0000

composable function is the replacement for xml files .
in classic way you use to handle many activity or fragment lifecycle.

so we focus on View lifecycle because there are many components in android that have their own lifecycle

> The lifecycle of a composable is defined by the following events: entering the Composition, getting recomposed 0 or more times, and leaving the Composition.

so here we treat something called Composition :)

so composable function has three lifecycle:

 -  enter composition
 -  recomposition n times
 -   leave composition

to observe your composable function's lifecycle you have to use class called State

> Recomposition is typically triggered by a change to a State object. Compose tracks these and runs all composables in the Composition that read that particular State, and any composables that they call that cannot be skipped.

to understand lifecycle also we need to know about Side-Effects methods in compose

> A side-effect is a change to the state of the app that happens outside the scope of a composable function.

> An effect is a composable function that doesn't emit UI and causes side effects to run when a composition completes.

there are many side-Effect function in compose
1)

LaunchedEffect:

run suspend functions in the scope of a composable
`

@Composable
fun MyScreen(
state: UiState>,
scaffoldState: ScaffoldState = rememberScaffoldState()
) {

// If the UI state contains an error, show snackbar
if (state.hasError) {

    // `LaunchedEffect` will cancel and re-launch if
    // `scaffoldState.snackbarHostState` changes
    LaunchedEffect(scaffoldState.snackbarHostState) {
        // Show snackbar using a coroutine, when the coroutine is cancelled the
        // snackbar will automatically dismiss. This coroutine will cancel whenever
        // `state.hasError` is false, and only start when `state.hasError` is true
        // (due to the above if-check), or if `scaffoldState.snackbarHostState` changes.
        scaffoldState.snackbarHostState.showSnackbar(
            message = "Error message",
            actionLabel = "Retry message"
        )
    }
}

Scaffold(scaffoldState = scaffoldState) {
    /* ... */
}

2)
rememberCoroutineScope:

obtain a composition-aware scope to launch a coroutine `outside a composable

@Composable
fun MoviesScreen(scaffoldState: ScaffoldState = rememberScaffoldState()) {

// Creates a CoroutineScope bound to the MoviesScreen's lifecycle
val scope = rememberCoroutineScope()

Scaffold(scaffoldState = scaffoldState) {
    Column {
        /* ... */
        Button(
            onClick = {
                // Create a new coroutine in the event handler to show a snackbar
                scope.launch {
                    scaffoldState.snackbarHostState.showSnackbar("Something happened!")
                }
            }
        ) {
            Text("Press me")
        }
    }
}

3)
rememberUpdatedState:

`> reference a value in an effect that shouldn't restart if the value changes

@Composable
fun LandingScreen(onTimeout: () -> Unit) {

// This will always refer to the latest onTimeout function that
// LandingScreen was recomposed with
val currentOnTimeout by rememberUpdatedState(onTimeout)

// Create an effect that matches the lifecycle of LandingScreen.
// If LandingScreen recomposes, the delay shouldn't start again.
LaunchedEffect(true) {
    delay(SplashWaitTimeMillis)
    currentOnTimeout()
}

/* Landing screen content */

}
`

4)
DisposableEffect:
effects that require cleanup

when composable function leaves the Composition

@Composable
fun HomeScreen(
lifecycleOwner: LifecycleOwner = LocalLifecycleOwner.current,
onStart: () -> Unit, // Send the 'started' analytics event
onStop: () -> Unit // Send the 'stopped' analytics event
) {
// Safely update the current lambdas when a new one is provided
val currentOnStart by rememberUpdatedState(onStart)
val currentOnStop by rememberUpdatedState(onStop)

// If `lifecycleOwner` changes, dispose and reset the effect
DisposableEffect(lifecycleOwner) {
    // Create an observer that triggers our remembered callbacks
    // for sending analytics events
    val observer = LifecycleEventObserver { _, event ->
        if (event == Lifecycle.Event.ON_START) {
            currentOnStart()
        } else if (event == Lifecycle.Event.ON_STOP) {
            currentOnStop()
        }
    }

    // Add the observer to the lifecycle
    lifecycleOwner.lifecycle.addObserver(observer)

    // When the effect leaves the Composition, remove the observer
    onDispose {
        lifecycleOwner.lifecycle.removeObserver(observer)
    }
}

/* Home screen content */

}
`

i hope you enjoying it:)

Dart basics - part 1

kururu — Wed, 23 Feb 2022 20:19:21 +0000

Dart is an open-source general-purpose programming language. It is originally developed by Google and later approved as a standard by ECMA. Dart is a new programming language meant for the server as well as the browser. Introduced by Google, the Dart SDK ships with its compiler.

dart has many similarities to other languages

in this topics we are going to focus in some basics of this new languages so can help you in your journey especially for those who want to try flutter

Variables :

in dart you van create variable use var keywords , or instead you specify the variable type

` var x= 'abdo';

// or

String y ='ahmed';`

using var is what they called it inferred type
so the type of the variable is detected by it's value

Note:
when using var keyword to initialize variable with a value which from specific type you cannot update the variable with value of different type

var x= 'abdo'; x=90; // show an error

Control Structure:

we mean the conditional  and iteration statements including:


-  if elese   
-  switch case
- for loop
- etc

**
IF ELSE**

`int x =9;
if(x>8){
print("x is bigger than 8");
} else {

print("x is less or equal  to 8");

Loop

for(int c=0;c<9;c++){ print(c); }

same to for loop in other languages like java

there is special loop come with list type like an array
called foreEach

it is a callback for the array , it iterates through all elements of the given array

List numbers =[2,232,23,89]; numbers.forEach((n){ print(n); });

*SWITCH CASE *

 same as switch case in java and many languages

` var name ='ali';

switch(name){
case 'ahmed':
print('it is ahmed');

  break;
case 'ali':
  print('it is ali');

  break;

default:
   print('none of above');

}
`

continued...

Messaging Queue system with Nodjes

kururu — Wed, 23 Feb 2022 19:47:01 +0000

i will create a chat system using socket io , rabbitMQ and database .

with rabbitmq you can send a message to queue when user is offline and after he connect , he will consume all messages in his queue.

any ideas? :)