DEV Community: Abhishek Srivastava

Google Play Store Rating & ReviewAPI

Abhishek Srivastava — Sat, 22 Apr 2023 18:51:18 +0000

Google announced an in-app review API that prompts users to submit Play store ratings and reviews without leaving the application and without opening the Play store either. Before it we show the dialog and for rating we move to play store app for rating and review which distract user from application. But for new Review API User can give rating and review without moving to play store and Users’ reviews/ratings will eventually be displayed in the Google Play store.

This encourages users to give feedback on your application.

Typically, this API concept is a better way of asking users for a review than the fallback rate dialog.

What are the benefits of integrating Google Play In-App Review API
There are two major flaws in the earlier setup for getting Play store ratings and reviews from users:

Users are prompted to rate the app, with an in-app survey and if the user hits the 5 stars, then the user is asked to rate the app in play store. Most of the users do not want to put the effort of rating twice, no matter how much they love your app.
The other flaw in the setup is that the users need to navigate out of the app to give the ratings. Which is also not really desirable.‍

With the In-App Review API, both of these flaws are countered. You don’t need to prompt users twice for the ratings, nor do they need to navigate out of the app to give the ratings and reviews.

How to implement Review & Rating API
Device Requirements:

You can use In-App Reviews in Android devices (phones and tablets) running Android 5.0 (API level 21) or higher that have the Google Play Store installed.

Integration
Step 1: Adding dependency
Add Google Core Library to your build.gradle file.
`

implementation 'com.google.android.play:core:1.9.0'
`
Sync to download the library to have access to the necessary classes to initiate review flow.

Always ensure that you are using the latest library version. Check here for newly added versions.

Step 2: Creating an instance of a ‘ReviewManager’

The ReviewManager provides the required functions that trigger the review flow.

They include:

requestReviewFlow() — fetches application information from the Play store.
launchReviewFlow() — initiates the review flow.
Declare ReviewManager right above onCreate().

To create an instance of ReviewManager:

Declare ReviewManager right above onCreate().
Use ReviewManagerFactory calling the create function, and pass your application context to it.

reviewManager = ReviewManagerFactory.create(getApplicationContext());
`
Step 3: Requesting review info
requestReviewFlow() communicates with the Google Play store remotely to get the information that references your application.

Declare ReviewInfo.

ReviewInfo reviewInfo;
ReviewInfo holds this information, that will be used to trigger the review flow process to the end user.

`
Task manager = reviewManager.requestReviewFlow();
manager.addOnCompleteListener(task -> {
if (task.isSuccessful()) {
reviewInfo = task.getResult();
} else {
}
});

`
`

Calling requestReviewFlow() will return the data associated with your play store application. This function performs an asynchronous operation, meaning we have to wait for the operation to complete.

For this reason, we need to assign a listener. The listener will let ReviewManager know when the Task is completed and assign the request’s results to ReviewInfo.

Step 4: Launching ReviewFlow

Referencing the ReviewFlow, we can start and show the review dialog to the user. However, in some instances, requestReviewFlow() can fail to get the application information, meaning that ReviewFlow will be null.

These instances include:

Poor internet connection.
A user has previously written a review for your application.
Quota restriction. Due to the quota imposed by this API, not every request will be successful.
For this reason, we need to start launchReviewFlow() if ReviewFlow is not null. Make sure you assign ReviewFlow to null.

ReviewInfo reviewInfo = null;
When null, the ReviewManager will terminate the review flow.

if (reviewInfo != null) { Task<Void> flow = reviewManager.launchReviewFlow(this, reviewInfo); flow.addOnCompleteListener(new OnCompleteListener<Void>() { @Override public void onComplete(Task<Void> task) { Toast.makeText(getApplicationContext(), "In App Rating complete", Toast.LENGTH_LONG).show(); } }); } else { }
`

When requestReviewFlow() is successful, ReviewFlow will be assigned to the request results. You need to check if reviewInfo != null to trigger the review flow with launchReviewFlow(). Then the API will handle the review’s comment and rating and update your application store listing showing them.

This API state’s that if an error occurs during the review flow, you should never inform the user or change your normal application flow. The app should continue its usual flow after onComplete is called.

Final code:

`
public class MainActivity extends AppCompatActivity {
ReviewManager reviewManager;
ReviewInfo reviewInfo = null;
@override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
getReviewInfo();
}

private void getReviewInfo() {
    reviewManager = ReviewManagerFactory.create(getApplicationContext());
    Task<ReviewInfo> manager = reviewManager.requestReviewFlow();
    manager.addOnCompleteListener(task -> {
        if (task.isSuccessful()) {
            reviewInfo = task.getResult();
            startReviewFlow();
        } else {
            Toast.makeText(getApplicationContext(), "In App ReviewFlow failed to start", Toast.LENGTH_LONG).show();
        }
    });
}

public void startReviewFlow() {
    if (reviewInfo != null) {
        Task<Void> flow = reviewManager.launchReviewFlow(this, reviewInfo);
        flow.addOnCompleteListener(new OnCompleteListener<Void>() {
            @Override
            public void onComplete(Task<Void> task) {
                Toast.makeText(getApplicationContext(), "In App Rating complete", Toast.LENGTH_LONG).show();
            }
        });
    }
    else {
        Toast.makeText(getApplicationContext(), "In App Rating failed", Toast.LENGTH_LONG).show();
    }
}

}
`
`

Testing
To test our application, we will use internal app sharing. To confirm that this works, add a Button to trigger the review flow. Remember, we are using a call to action for testing. In production applications, calls to action such as Button should be avoided when using this API.

Create reference and manage OnClickListener and call startReviewFlow()

mButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View view) { startReviewFlow(); } });
`
How to test

Generate a signed app bundle/APK. Note the APK signing key and the applicationId should be the same as the already published application.
Share the generated APK with a tester. To do that, select the published application in the Google console, navigate to Internal App Sharing, and upload the generated APK there. Check how to use Google Internal App Sharing.
Copy the upload’s shareable link and share it with a tester. In this case, a tester should be using an Android mobile phone.
Open the shared link on the phone’s browser. You will be prompted to open with the Google Play store. Do so. This will launch a Play store screen.
Download the app and wait for the installation to complete.
Launch the application and click SHOW IN APP REVIEW DIALOG to start the review flow, as shown in the image below.

Note:

Since we a carrying out a test, the submit button will be inactive.
If you have previously reviewed the application, delete your comment in the Google Play store. Otherwise, the review sheet won’t pop up.
For more reference, check the code of @joseph chege on GitHub.
What is the best way to make use of Google Play In-App Review API
Standard Developer Guidelines to help you decide when to request in-app reviews from users:
Trigger the in-app review flow after a user has experienced enough of your app or game to provide useful feedback.
Do not prompt the user excessively for a review. This approach helps minimize user frustration and limit API usage.
Your app should not ask the user any questions before or while presenting the rating button or card, including questions about their opinion (such as “Do you like the app?”) or predictive questions (such as “Would you rate this app 5 stars”).
There is a cap on the number of times a user is shown the review dialog, and this is called Quota. This limit has been enforced by Google to ensure that user experience is not disrupted by a flood of such requests. Hence, as per guidelines, it’s not optimal to have a call-to-action mechanism to launch the in-app review.

How In-App Review API works
The in-app review flow can be triggered at any time throughout the user journey of your app. During the flow, the user has the ability to rate your app using the 1 to 5 star system and to add an optional comment. Once submitted, the review is sent to the Play Store and eventually displayed.

Check the documentation guidelines regarding when you should request the review flow.

The API states that you need to note the following:

How you ask for reviews matters. When using this API, you should not ask predictive or opinionated questions before or after the review sheet dialogs show the app in your application. These questions include:
Would you rate this application five stars?
Do you like this app?

The API also advises you only to show dialog once a user has enough. experience with your application. It’s not a good practice to ask a user to write a review before the app delivers value to that user. Chances are, the user will get annoyed and skip the review. And if they don’t skip it, they will give negative reviews.
In order to minimize API usage and avoid annoying users, it would be best if you did not excessively ask users to write reviews.

Thanks for the reading…

Kotlin Common tips for developers

Abhishek Srivastava — Sat, 14 Jan 2023 16:19:28 +0000

1. What is difference between value class and inline class

Value classes are value-based classes that wrap primitive values. As of now, Kotlin value classes only support wrapping one single primitive value and it provide type safety. However, wrapping a primitive type can be very costly in terms of performance.

Value classes deceleration might look pretty similar to data classes. The signature looks exactly the same, except that instead of data class the keyword is value class


@JvmInline
value class DisplayBrightness(val value: Double)

fun setDisplayBrightness(newDisplayBrightness: DisplayBrightness) { ... }

You might have noticed the @JvmInline annotation. In short, while the Kotlin/Native and Kotlin/JS backends would technically support value classes with more than one field, Kotlin/JVM currently does not. This is because the JVM only supports its built-in primitive types. so they needed to find a temporary compilation strategy that can be employed now. In order to make this obvious, @JvmInline is enforced for the time being.

Behind the scenes, the compiler treats value classes like a type alias — with one major difference: Value classes are not assignment-compatible, meaning that this code will not compile:

@JvmInline
value class DisplayBrightness(val value: Double)

fun setDisplayBrightness(newDisplayBrightness: DisplayBrightness) { ... }

fun callingFunction() {
    val weight: Double = 85.4
    setDisplayBrightness(weight) // 💥
}

Inline classes have some, more or less apparent, restrictions though: It’s required to specify precisely one property in the primary constructor, as shown with value. You can't wrap multiple values in one inline class. It is also prohibited to have init blocks in inline classes, and you cannot have properties with backing fields. Inline classes can have simple computable properties.

At runtime, the wrapped type of an inline class will be used without its wrapper whenever possible. This is similar to Java’s boxed types like Integer or Boolean, which will be represented as their corresponding primitive type whenever the compiler can do that. That exactly is the great selling point for inline classes in Kotlin: When you inline a class, the class itself won't be used in the byte code unless it's absolutely necessary. Inlining classes drastically reduces space overhead at runtime.

inline class Password(val value: String)
inline class UserName(val value: String)

fun auth(userName: UserName, password: Password) { println("authenticating $userName.")}

fun main() {
    auth(UserName("user1"), Password("12345"))
    //does not compile due to type mismatch
    auth(Password("12345"), UserName("user1"))
}

2. What does ‘by’ keyword do in Kotlin

Kotlin supports delegation of design pattern by introducing a new keyword “by”. Using this keyword or delegation methodology, Kotlin allows the derived class to access all the implemented public methods of an interface through a specific object.

In simple words, you can understand by keyword as provided by.

From the perspective of property consumer, val is something that has getter (get) and var is something that has getter and setter (get, set). For each var property there is a default provider of get and set methods that we don't need to specify explicitly.

But, when using by keyword, you are stating that this getter/getter&setter is provided elsewhere (i.e. it's been delegated). It's provided by the function that comes after by.

So, instead of using this built-in get and set methods, you are delegating that job to some explicit function.

One very common example is the by lazy for lazy loading properties. Also, if you are using dependency injection library like Koin, you'll see many properties defined like this:

var myRepository: MyRepository by inject()  //inject is a function from Koin

In the class definition, it follows the same principle, it defines where some function is provided, but it can refer to any set of methods/properties, not just get and set.

class MyClass: SomeInterface by SomeImplementation, SomeOtherInterface

This code is saying: 'I am class MyClass and I offer functions of interface SomeInterface which are provided by SomeImplementation. I'll implement SomeOtherInterface by myself (that's implicit, so no by there).'

3. What does ‘*’ in Kotlin when used within <>

Star projection, denoted by the * character may be helpful to think of the star projection as a way to represent not just any type, but some fixed type which you don’t know what is exactly.

For example, the type MutableList<*> represents the list of something (you don't know what exactly). So if you try to add something to this list, you won't succeed. It may be a list of Strings, or a list of Ints, or a list of something else. The compiler won't allow to put any object in this list at all because it cannot verify that the list accepts objects of this type. However, if you attempt to get an element out of such list, you'll surely get an object of type Any?, because all objects in Kotlin inherit from Any.

4. What does ‘*’ in Kotlin when used with list iteration

The * operator is known as the Spread Operator in Kotlin.

When we call a vararg-function, we can pass arguments one-by-one, e.g. asList(1, 2, 3), or, if we already have an array and want to pass its contents to the function, we use the spread operator (prefix the array with *):

It can be applied to an Array or with any collection before passing it into a function that accepts varargs.

If you have a function that accepts a varied number of arguments…

fun sumOfNumbers(vararg numbers: Int): Int {
    return numbers.sum()
}

Use the spread operator to pass an array’s elements as the arguments:

val numbers = intArrayOf(2, 3, 4)
val sum = sumOfNumbers(*numbers)
println(sum) // Prints '9'

Notes:

The * operator is also the multiplication operator (of course).
The operator can only be used when passing arguments to a function. The result of the operation cannot be stored since it yields no value (it is purely syntactic sugar).
The operator may confuse some C/C++ programmers at first because it looks like a pointer is being de-referenced. It isn’t; Kotlin has no notion of pointers.
The operator can be used in-between other arguments when calling a vararg function. This is demonstrated in the example here.
The operator is similar to the apply function in various functional programming languages.

5. Kotlin’s difference between vararg and spread operator

vararg in Kotlin
Kotlin also supports declaring a function that can have a variable number of arguments. You can do that by prefixing parameter name with the vararg modifier: fun format(format: String, vararg args: Any)

Rules: In Java, the vararg parameter has to be the last one in the parameters list — so you can only have one vararg parameter. While in Kotlin, the vararg parameter doesn’t have to be the last one in the list, multiple vararg parameters are still prohibited.

Now let’s see how the decompiled corresponding Java source code looks like when declaring vararg parameters.

Declaring vararg param as the last one in list, in a Kotlin function, looks like this:

fun format(format: String, vararg params: String)

and will be compiled into the corresponding Java code:

void format(@NotNull String format, @NotNull String... params)

Spread operator
Kotlin’s spread operator — the operator that unpacks an array into the list of values from the array. It is needed when you want to pass an array as the vararg parameter.

If you try to call format function defined above like this:

val params = arrayOf("param1", "param2")
format(output, params)

it will fail with Type mismatch: inferred type is Array but String was expected compilation error.

To fix this, you need to use spread operator to unpack params array into the corresponding values: format(output, *params)

Let’s see how the corresponding decompiled Java code looks like in this case:

String[] params = new String[]{"param1", "param2"};
format(output, (String[])Arrays.copyOf(params, params.length))

When using the spread operator, you can pass additional values to the vararg parameter — or even combine multiple spread arrays in the same parameter:


val params = arrayOf("param1", "param2")
val opts = arrayOf("opts1", "opts2", "opts3")
format(output, *params, "additional", *opts)

6. Difference between “fold” and “reduce” in Kotlin

fold() and reduce() are two different methods, both are helpful for traversing a collection. We will see how and when to use these two methods.

fold()
If we want to traverse through a collection serially, then we can use fold().

fold() takes one initial value and one operation to perform the operation on the initial value.
There are different kinds of fold(), for example, foldRight() folds from right to left. By default, fold() will traverse from left to right. The following example demonstrates how to use fold() to traverse through a collection.

fun main(args: Array<String>) {
val MyTotal = listOf(1, 2, 3, 4, 5).fold(0) {
      initialValue, result -> result + initialValue
   }
   print("The sum of list members: " +MyTotal)
}

Output : fold() will start the operation from the 0th index and it will end its operation and store the final value in MyTotal.

The sum of list members: 15

reduce()
reduce() is one of the default methods in Kotlin that helps to convert a given set of collection into a single set output result. reduce() is one of the built-in functions that can be applied on a given collection. It takes the first and second elements as the operation argument and this is the main difference between reduce() and fold().

fun main(args: Array<String>) {
   val x = listOf(1,2,3,4,5,6,7,8,9)
   val y = x.reduce { y, vars -> y + vars }
   println("The value of reduce() ---> "+y)
}

Output: The value of reduce() ---> 45

Thanks for reading…

Types of Classes in Kotlin

Abhishek Srivastava — Sat, 31 Dec 2022 18:18:24 +0000

I wish I had started playing around with the more idiomatic ways to write Kotlin code much sooner since it improves the quality of the code and makes writing code much more enjoyable. I agree that you can easily get by without ever using the less-known Kotlin features, however, in the hands of more dedicated software enthusiasts, those features can help improve the code dramatically.

Kotlin supports both functional and object-oriented programming. While talking about functional features of Kotlin then we have concepts like functions, higher-order functions and lambdas etc. which represent Kotlin as a functional language.
Kotlin also supports Object Oriented Programming (OOP) and provides features such as abstraction, encapsulation, inheritance, etc. This tutorial will teach you all the Kotlin OOP features in simple steps.

Kotlin Class
Kotlin class is similar to Java class, a class is a blueprint for the objects which have common properties. Kotlin classes are declared using keyword class. Kotlin class has a class header which specifies its type parameters, constructor etc. and the class body which is surrounded by curly braces.
There are different types of Kotlin classes availbale, Lets start discuss about each class one by one.
Kotlin classes are final by default. Other classes cannot inherit from a final class. To make a class inheritable, we mark it with the open keyword.

1. Inline classes
Inline classes allow creating wrappers for a value of a certain type and such wrappers would be fully inlined. This is similar to type aliases but inline classes are not assignment-compatible with the corresponding underlying types.
Use cases:
Unsigned types

@JvmInline
value class UInt(private val value: Int) { ... }
@JvmInline
value class UShort(private val value: Short) { ... }
@JvmInline
value class UByte(private val value: Byte) { ... }
@JvmInline
value class ULong(private val value: Long) { ... }

Native types like size_t for Kotlin/Native

Inline enum classes

Int enum for Android IntDef
String enum for Kotlin/JS (see WebIDL enums)

Example:

@JvmInline 
enum class Foo(val x: Int) 
{ 
       A(0), B(1); 
    fun example() { … } 
}

The constructor's arguments should be constant values and the values should be different for different entries.
Units of measurement
Result type (aka Try monad) KT-18608
Inline property delegates

class A {
    var something by InlinedDelegate(Foo()) // no actual instantiation of `InlinedDelegate`
}

@JvmInline
value class InlinedDelegate<T>(var node: T) {
    operator fun setValue(thisRef: A, property: KProperty<*>, value: T) {
        if (node !== value) {
            thisRef.notify(node, value)
        }
        node = value
    }
    operator fun getValue(thisRef: A, property: KProperty<*>): T {
        return node
    }
}

Inline wrappers
Typed wrappers

@JvmInline
value class Name(private val s: String)
@JvmInline
value class Password(private val s: String)

fun foo() {
    var n = Name("n") // no actual instantiation, on JVM type of `n` is String
    val p = Password("p")
    n = "other" // type mismatch error
    n = p // type mismatch error
}
API refinement

// Java
public class Foo {
    public Object[] objects() { ... }
}

// Kotlin
@JvmInline
value class RefinedFoo(val f: Foo) {
    inline fun <T> array(): Array<T> = f.objects() as Array<T>
}

Inline classes are declared using soft keyword value and must have a single property:
value class Foo(val i: Int)
In Kotlin/JVM, however, they should be annotated with additional @JvmInline annotation:

@JvmInline
value class Foo(val i: Int)

In Kotlin/Native and Kotlin/JS, because of the closed-world model, value-based classes with single read-only property are inline classes. In Kotlin/JVM we require the annotation for inline classes, since we are going to support value-based classes, which are a superset of inline classes, and they are binary incompatible with inline classes. Thus, adding and removing the annotation will be a breaking change.
The property i defines type of the underlying runtime representation for inline class Foo, while at compile time type will be Foo.
From language point of view, inline classes can be considered as restricted classes, they can declare various members, operators, have generics.

Example:

@JvmInline
value class Name(val s: String) : Comparable<Name> {
    override fun compareTo(other: Name): Int = s.compareTo(other.s)

    fun greet() {
        println("Hello, $s")
    }
} 

fun greet() {
    val name = Name("Kotlin") // there is no actual instantiation of class `Name`
    name.greet() // method `greet` is called as a static method
}

Current limitations
Currently, inline classes must satisfy the following requirements:
Inline class must have a primary constructor with a single value parameter
Inline class must have a single read-only (val) property as an underlying value, which is defined in primary constructor
Underlying value cannot be of the same type that is containing inline class
Inline class with undefined (recursively defined) generics, e.g. generics with an upper bound equal to the class, is prohibited

@JvmInline
value class A<T : A<T>>(val x: T) // error

Inline class must be final
Inline class can implement only interfaces
Inline class cannot have backing fields
Hence, it follows that inline class can have only simple computable properties (no lateinit/delegated properties)
Inline class must be a toplevel or a nested class. Local and inner inline classes are not allowed.
Inline classes cannot have context receivers.
Inline classes cannot have var properties with backing fields.

For more detail about inline class and other. You can click here.

Kotlin empty class In the following example, we create two empty classes.

EmptyClass.kt
package com.demo

class Being {}
class Empty
fun main() {
    val b = Being()
    println(b)
    val e = Empty()
    println(e)
}

An empty class has no members or member functions. The curly brackets can be omitted.

Kotlin data class Some classes are desinged to hold data. With data classes, we can considerably reduce the boilerplate code. Compiler automatically creates the equals, hashCode, toString, and copy functions. A data class in Kotlin is created with the data keyword. The data classes must follow a couple of rules. The primary constructor needs to have at least one parameter. All primary constructor parameters must be marked as val or var. The data classes cannot be abstract, open, sealed or inner.

data class User(val name: String, val email: String)

fun main() {

    val u = User("Peter Novak", "pnovak47@gmail.com")
    println(u)

    println(u.name)
    println(u.email)

    val (name, email) = u;
    println("$name $email")

    val u2 = User("Peter Novak", "pnovak47@gmail.com")

    println(u == u2)
    println(u === u2)
}

Kotlin abstract class Kotlin supports abstract classes - just like Java, these are classes which you never intend to create objects from. An abstract class is incomplete or useless without some concrete (non-abstract) subclasses, from which you can instantiate objects. A concrete subclass of an abstract class implements all the methods and properties defined in the abstract class - otherwise that subclass is also an abstract class! We create an abstract class with the abstract modifier (similar to Java).

abstract class Employee (val firstName: String, val lastName: String) {
    abstract fun earnings(): Double
}

Note that not all members have to be abstract. In other words, we can have method default implementation in an abstract class.

abstract class Employee (val firstName: String, val lastName: String) {
    // ... 

    fun fullName(): String {
        return lastName + " " + firstName;
    }
}

Here we created the non-abstract function fullName() in an abstract class Employee. Concrete classes (subclasses of the abstract class) can override an abstract method's default implementation-but only if the method has the open modifier specified (you will learn more about this shortly).

Kotlin sealed class A sealed class is used for representing restricted class hierarchies. A value can have one of the types from a limited set, but cannot have any other type. Sealed classes are more powerful enum classes. Note: in some languages, such as C# or Scala, a sealed class is a class which prohibits inheritance. Sealed classes are abstract and can have abstract members; this means that they cannot be instantiated directly. Sealed classes cannot have public constructors (The constructors are private by default). Sealed classes can have subclasses, but they must either be in the same file or nested inside of the sealed class declaration.

sealed class Shape
class Circle(var radius: Float) : Shape()
class Square(var width: Int) : Shape()
class Rectangle(var width: Int, var height: Int) : Shape()

fun getArea(e: Shape) =
    when (e) {
        is Circle -> println("Circle area is ${Math.PI * e.radius * e.radius}")
        is Square -> println("Square area is ${e.width * e.width}")
        is Rectangle -> println("Rectangle area is ${e.width * e.height}")
    }

fun main() {

    val circle = Circle(7f)
    val square = Square(5)
    val rectangle = Rectangle(8, 6)

    getArea(circle)
    getArea(square)
    getArea(rectangle)
}

In the example, we have a sealed Shape class. It has three subclasses: Circle, Square, and Rectangle.

fun getArea(e: Shape) =
    when (e) {
        is Circle -> println("Circle area is ${Math.PI * e.radius * e.radius}")
        is Square -> println("Square area is ${e.width * e.width}")
        is Rectangle -> println("Rectangle area is ${e.width * e.height}")
    }

The getArea function calculates the area for a shape. Note that the else statement is not needed, since the compiler knows that the list of options is exhaustive.

Circle area is 153.93804002589985
Square area is 25
Rectangle area is 48

Kotlin nested class A nested class is declared inside another class.

class Outer {

    val name = "Outer"
    fun show() = "the name: $name"

    class Nested {
        val name = "Nested"
        fun show() = "the name: $name"
    }
}

fun main() {

    println(Outer().show())
    println(Outer.Nested().show())
}

In order to access the nested class, we specify the name of its outer class. So the show function of the nested class is invoked like this: Outer.Nested().show. A nested class cannot access the members of the outer class.

Kotlin inner class Inner classes are created with the inner keyword. Unlike nested classes, they can access the members of their outer classes.

class Outer {

    val name1 = "Outer"
    fun show() = "the name: $name1"

    inner class Inner {

        val name2 = "Inner"
        fun show() = "data: $name2 and $name1"
    }
}
fun main() {

    println(Outer().show())
    println(Outer().Inner().show())
}

In the example, we have one inner class. Its show function outputs the name1 member of the Outer class.

ChatGPT: OpenAI’s new Artificial Intelligent chatbot

Abhishek Srivastava — Wed, 21 Dec 2022 10:26:30 +0000

_There’s a new AI bot in town: ChatGPT. The tool, from a power player in artificial intelligence, lets you type questions using natural language that the chatbot answers in conversational, if somewhat stilted, language. The bot remembers the thread of your dialog, using previous questions and answers to inform its next responses. Its answers are derived from huge volumes of information on the internet.

What is ChatGPT?
Using dialogue-based AI, ChatGPT can understand the natural language of humans and produce text that is remarkably detailed and human-like. It is a recent development in the text-generating AIs known as the “generative pre-trained transformer” (GPT). For full detail click here.

ChatGPT, a bot that converses with humans via cutting-edge artificial intelligence. The bot can help you write code, compose essays, dream up stories, and decorate your living room. And that’s just what people discovered on day one. Click here to know about ChatGBT 3 from here.

Who created it?
A chatbot called ChatGPT was introduced by artificial intelligence researcher Jeremy Howard.

The newest chatbot from Elon Musk’s research organization, OpenAI, is the new AI. In a blog post from late 2015, Musk stated that the research centre would “advance digital intelligence in the way that is most likely to benefit humanity.”

ChatGPT is developed by OpenAI Inc. which is a California-based company and it is famous for its GPT-3 Software. GPT-3 software was released to reply to text prompts.

When did the Chat GPT launch?
The OpenAI GPT-3.5 language model, an upgraded version of GPT-3, served as the foundational model that was adjusted. Although its factual accuracy has been criticized, ChatGPT has gained attention for its in-depth and thoughtful responses since its November 2022 launch.

How does it function?
The system is created to provide information and respond to queries through a conversational interface. A sample text pulled from the internet is used to train the AI. The new AI was developed with a focus on usability. The research organization stated last week that “the dialogue format makes it possible for ChatGPT to answer follow-up questions, admit its errors, challenge false premises, and reject inappropriate requests.”

What is its use?
Because it can provide descriptions, answers, and solutions to complex questions, including how to write code, how to solve layout issues, and how to answer optimization queries, the technology has been referred to by early users as a Google alternative.

Applications in the real world might include producing content for websites, responding to customer inquiries, making recommendations, and developing automated chatbots. The system was described as “an early demo of what’s possible” by Sam Altman, CEO of OpenAI. Soon, you’ll be able to communicate with helpful assistants who can respond to your questions and offer guidance. Later, you’ll be able to have something that works for you automatically. You may eventually have something set off that finds new information for you.

Can humans be replaced by ChatGPT?
There has been speculation that occupations reliant on content creation, such as playwrights, professors, programmers, and journalists, could become obsolete. Since its release, academics have produced exam answers that they claim would receive full marks if submitted by an undergraduate, and programmers have used the tool to quickly solve coding problems in specialized programming languages. Some people have suggested that technology could replace journalists because it can produce written text that looks and sounds like human speech. The chatbot, however, lacks the sophistication, critical-thinking abilities, or capacity for moral judgment that are necessary for successful journalism at this point. Some queries and searches will be useless after the current knowledge base expires in 2021. According to the company, ChatGPT can also write “plausible-sounding but incorrect or nonsensical answers,” which present incorrect information as fact. The data that OpenAI uses to train the model lacks a source of truth and supervised training can be deceptive because “the ideal answer depends on what the model knows, rather than what the human demonstrator knows,” according to OpenAI.

Is ChatGPT free?
Yes, for now at least. OpenAI CEO Sam Altman warned on Sunday, “We will have to monetize it somehow at some point. The compute costs are eye-watering.” OpenAI charges for DALL-E art once you exceed a basic free level of usage.

Could ChatGPT replace humans?
There has been speculation that professions dependent upon content production could be rendered obsolete, including everything from playwrights and professors to programmers and journalists.

Features of ChatGPT

It can understand and respond in the natural Language.
This technology uses deep learning to produce human-like text that can respond to everything from stories, Mathematical solutions to theoretical essays.
ChatGPT can remember earlier comments in a conversation and recount them to the user with its unique memory.
Its intelligence can provide a detailed answer to historical arguments to poems on any topic.
In comparison to its predecessor, InstructGPT, ChatGPT attempts to reduce harmful and deceitful responses to the users.
ChatGPT was developed in such a way that it uses reinforcement learning from human feedback.
ChatGPT can suggest anything about how to celebrate a birthday party, and how to write an essay. It helps to solve the reasoning questions

What are the limits of ChatGPT?
As OpenAI emphasizes, ChatGPT can give you wrong answers. Sometimes, helpfully, it’ll specifically warn you of its own shortcomings. For example, when I asked it who wrote the phrase “the squirming facts exceed the squamous mind,” ChatGPT replied, “I’m sorry, but I am not able to browse the internet or access any external information beyond what I was trained on.” (The phrase is from Wallace Stevens’ 1942 poem Connoisseur of Chaos.)

ChatGPT was willing to take a stab at the meaning of that expression: “a situation in which the facts or information at hand are difficult to process or understand.” It sandwiched that interpretation between cautions that it’s hard to judge without more context and that it’s just one possible interpretation.

ChatGPT’s answers can look authoritative but be wrong.

The software developer site StackOverflow banned ChatGPT answers to programming questions. Administrators cautioned, “because the average rate of getting correct answers from ChatGPT is too low, the posting of answers created by ChatGPT is substantially harmful to the site and to users who are asking or looking for correct answers.”

You can see for yourself how artful a BS artist ChatGPT can be by asking the same question multiple times. I asked twice whether Moore’s Law, which tracks the computer chip industry’s progress increasing the number of data-processing transistors, is running out of steam, and I got two different answers. One pointed optimistically to continued progress, while the other pointed more grimly to the slowdown and the belief “that Moore’s Law may be reaching its limits.”

Both ideas are common in the computer industry itself, so this ambiguous stance perhaps reflects what human experts believe.

With other questions that don’t have clear answers, ChatGPT often won’t be pinned down.

The fact that it offers an answer at all, though, is a notable development in computing. Computers are famously literal, refusing to work unless you follow exact syntax and interface requirements. Large language models are revealing a more human-friendly style of interaction, not to mention an ability to generate answers that are somewhere between copying and creativity.

Will ChatGPT help students cheat better?
Yes, but as with many other technology developments, it’s not a simple black and white situation. Decades ago, students could copy encyclopedia entries, and more recently, they’ve been able to search the internet and delve into Wikipedia entries. ChatGPT offers new abilities for everything from helping with research to doing your homework for you outright. Many ChatGPT answers already sound like student essays, though often with a tone that’s stuffier and more pedantic than a writer might prefer.

Can ChatGPT write software?
es, but with caveats. ChatGPT can retrace steps humans have taken, and it can generate actual programming code. You just have to make sure it’s not bungling programming concepts or using software that doesn’t work. The StackOverflow ban on ChatGPT-generated software is there for a reason.

But there’s enough software on the web that ChatGPT really can work. One developer, Cobalt Robotics Chief Technology Officer Erik Schluntz, tweeted that ChatGPT provides useful enough advice that over three days, he hasn’t opened StackOverflow once to look for advice.

Another, Gabe Ragland of AI art site Lexica, used ChatGPT to write website code built with the React tool.

ChatGPT can parse regular expressions (regex), a powerful but complex system for spotting particular patterns, for example dates in a bunch of text or the name of a server in a website address. “It’s like having a programming tutor on hand 24/7,” tweeted programmer James Blackwell about ChatGPT’s ability to explain regex.

Here’s one impressive example of its technical chops: ChatGPT can emulate a Linux computer, delivering correct responses to command-line input.

What’s off limits?
ChatGPT is designed to weed out “inappropriate” requests, a behavior in line with OpenAI’s mission “to ensure that artificial general intelligence benefits all of humanity.”

If you ask ChatGPT itself what’s off limits, it’ll tell you: any questions “that are discriminatory, offensive, or inappropriate. This includes questions that are racist, sexist, homophobic, transphobic, or otherwise discriminatory or hateful.” Asking it to engage in illegal activities is also a no-no.

Is this better than Google search?
Asking a computer a question and getting an answer is useful, and often ChatGPT delivers the goods.

Google often supplies you with its suggested answers to questions and with links to websites that it thinks will be relevant. Often ChatGPT’s answers far surpass what Google will suggest, so it’s easy to imagine GPT-3 is a rival.

But you should think twice before trusting ChatGPT. As with Google itself and other sources of information like Wikipedia, it’s best practice to verify information from original sources before relying on it.

Vetting the veracity of ChatGPT answers takes some work because it just gives you some raw text with no links or citations. But it can be useful and in some cases thought provoking. You may not see something directly like ChatGPT in Google search results, but Google has built large language models of its own and uses AI extensively already in search.

So ChatGPT is doubtless showing the way toward our tech future.

Thanks for reading..

Android Work profile(Privacy and productivity on your personal device)

Abhishek Srivastava — Wed, 21 Dec 2022 07:04:22 +0000

What Is the Android Work Profile?
For those of you not familiar with Android’s work profile, it is a way for IT to provide access to work apps and resources on your Android device, while ensuring your private data is separate and not visible to IT.

Android work features are supported on Lollipop, Marshmallow, Nougat and Oreo devices and offers a dedicated work profile with security, management and application support built‑in.

In fact, the work apps have a briefcase logo on the app icon to indicate that the app has been provided by your organization. All my work apps are also organized in a “Work” folder so I can easily access it from the home screen. I can sleep soundly every night knowing that with the work profile, IT has absolutely no way of completely wiping my phone clean and deleting my personal data, such as my priceless family photos.

To get the work profile on my phone, all I had to do was install the AirWatch Agent and authenticate with my corporate credentials. As soon as enrollment was complete, I saw the creation of the work profile on my home screen with the badged work apps.

And it also enables device admins to take control of the corporate data and applications running on the device without preventing the device owner from using the primary profile functionality. For more detail click here.

Android separates business apps from personal apps so you can use your favorite Android device for both work and play.

How do I get Set Up With Google Mobile Management and Work Profiles?
Google’s post on the change gives detailed instructions for getting set up with Google Mobile Management and implementing work profiles. The requirements are:

Your company must be a G Suite client of any level
You must have Google Mobile Management enabled
The device must have the Lollipop, Marshmallow or Nougat version of Android
Android advanced management has been enabled
Your business has whitelisted apps it wants available for Work Profiles on Google Play

While Work Profiles are attractive for BYOD devices, the setup is admittedly cumbersome for a business without an active IT department — or for businesses with overworked IT departments. Contact UpCurve Cloud today to get us to install it for you, or to explain the benefits of using Google Mobile Management for your company Android devices.

To check the complete list of work profile feature. Click Here

To check Google app also from play store:-
https://play.google.com/store/apps/details?id=com.google.android.apps.work.clouddpc&hl=en_US&gl=US&pli=1

Android Work Profile Apps and Android 12
Android 12 represents an effort to better communicate to users how they are being tracked, and why. Of course, this impacts work profile apps. IT admins must be very careful about the information they request from users, and how they choose to manage devices.

The biggest change comes in terms of the new Privacy Dashboard feature. This provides users with a list of apps currently tracking device data. Developers can add text to justify what data they track, so users can decide whether or not to permit tracking. Still, this leaves admins in a tough position. Increased transparency requires greater communication from admins to users, so users do not feel their privacy has been violated.

Users with a work profile have the ability to approve or deny tracking permissions. While IT admins can prohibit tracking, and prevent users from enabling tracking, admins cannot force tracking on work profile apps. This means user consent is necessary for monitoring work-profile devices.

Additionally, Android 12 brings changes to the way Android Work Profile Apps are protected with security challenges. Users can now choose either to have their device password meet rigorous standards, or set an alternate security challenge exclusively for work profile apps.

Does my device have a work profile?
Go to Settings > Accounts. If you have a work profile, it’s listed in the Work section. On some devices, work profiles are also listed directly in Settings.

How do I access my work apps?
Note: Some of these steps work only on Android 9.0 and up. Learn how to check your Android version.

Work apps are marked with a briefcase icon so you can distinguish them from personal apps. To access your work apps:

Swipe up from the bottom of your screen to the top.

Tap the “Work” tab.
Tap the app that you want to open.
If your work app icons are gray, your work profile may be paused. Find out how to pause or turn on your work profile.

Points to be noted before started

Make sure to have an Android device that supports the Lollipop version or upwards.
WSO2 IoT Server implements data containerization using the Android Managed Profile feature, which is only available on Android Lollipop OS version and above.
Do you have work profile that is already running on your device? If yes, on your device, go to Settings > Accounts and remove it. Else, you run into errors.
Start the WSO2 IoT Server core profile.
cd /bin sh iot-server.sh

How to work with Android Agent
There are lots of steps to do that. Follow the steps given below to get the Android Agent.

Using QR CODE
Sign in to the Device Management console. Click here.
Click Enroll New Device. If you are an Admin user, click the menu icon, and select DEVICE MANAGEMENT, to access the ENROLL DEVICE button.
Click Android to enroll your device with WSO2 IoT Server.
Enroll the device.

A. Click Enroll Device.

B. Scan the QR code to download the Android agent onto your Android device.

- You need to make sure that your Android device and the IoT Server are on the same network, else you will not be able to download the Android agent.

- After scanning the QR code you will be directed to a web page. When this page appears, the web browser will typically display an "insecure connection" message, which requires your confirmation before you can continue.

- The WSO2 IoT Server consoles are based on the HTTPS protocol, which is a combination of HTTP and SSL protocols. This protocol is generally used to encrypt the traffic from the client to server for security reasons. The certificate it works with is used for encryptiononly,and does not prove the server identity, so when you try to access these consoles, a warning of untrusted connection is usually displayed. To continue working with this certificate, some steps should be taken to "accept" the certificate before access to the site is permitted. If you are using the Mozilla Firefox browser, this usually occurs only on the first access to the server, after which the certificate is stored in the browser database and marked as trusted. However, with other browsers, the insecure connection warning might be displayed every time you access the server.

- This scenario is suitable for testing purposes, or for running the program on the company's internal networks. If you want to make these consoles available to external users, your organization should obtain a certificate signed by a well-known certificate authority, which verifies that the server actually has the name it is accessed by and that this server belongs to the given organization.

Click Download Android Agent.

2. Inviting via Email
Sign in to the Device Management console. Click here.
Click Invite by Email.
Enter the email address of the users who needsto enroll their device with WSO2 IoT Server, and click Send Invite(s).
If you entered your email address, you will receive the registration email.

3. Downloading via APK
Sign in to the Device Management console. Click here.
Click Download APK.
Copy the downloaded file to your mobile device.
What is the use of create Android Work Profile?
There are lots of benefit using Android work profile, Which are below:-

Work smarter We can all agree that when you pick up your phone (more often than we’d like to admit) to check Twitter, read text messages or change what is playing on Spotify, you do not want to constantly enter a complex passcode. With the work profile, I still get to choose what type of password I want to unlock my phone. I just unlock my phone with my fingerprint, and a complex passcode prompt is only shown to me when I try to launch an app in the work profile.

I have added my Bluetooth headphones as a “trusted device,” so when I am listening to music, I am not prompted to enter a passcode to unlock the device. However, trusted devices do not apply to the work profile. I am always shown a passcode prompt when I launch a work app, and my trusted device preferences for the personal side are not affected.

Put the power, flexibility and choice of Android to work for you — anytime, from anywhere with best-in-class productivity apps.

Protect personal data I work hard to customize my phone as much as possible. Like fine-tuning the perfect Spotify playlist, it’s important to have a phone that gets your commands and gestures and can predict exactly what you’re looking for. Luckily, with the work profile, my phone still gets me, but now it gets me across my personal and professional personas.

My work apps are not downloaded using my personal Google account, so my app recommendations on my personal Play Store are not affected. I have different bookmarks for my personal and work Chrome browsers, as well. The bookmarks in my work Chrome browser are useful intranet sites, while the bookmarks on my personal Chrome browser are filled with my favorite tech blogs and news feeds.

With the work profile, my phone still gets me, but now it gets me across my personal and professional personas.

I even get different predictions from my work Chrome browser versus my personal. On my work Chrome browser, when I type the letter “V,” I get a prediction back about VMware, whereas on my personal Chrome browser, when I type the letter “V,” I get back something related to virtual reality or video games.

Set up a dedicated work profile for business content that never mixes with your personal stuff, so IT can’t see or erase your photos, emails, or other personal data.

Control data and privacy For devices running Ice Cream Sandwich through Kitkat, or that don’t run work profiles natively, we’ve created the Android for Work app. The app, which delivers secure mail, calendar, contacts, documents, browsing and access to approved work apps, can be completely managed by IT.

If you leave the company or your device is lost, IT will erase just the work apps, leaving your personal stuff intact. IT can also never view your personal activities.

Enjoy a familiar experience The briefcase icon is present throughout the Android experience, not just in the work folder. When I receive a notification from a work app, it has the briefcase icon so I know it’s work related.

If I search for a work contact within the personal Phone app, they are shown separate from my personal contacts and personal directory integrations (and have the briefcase icon). In the Recent Apps view, apps from the work profile have the word “Work” added in.

There’s no learning curve when you bring your own device to work. The work features in Android enhance the native interface without changing the experience you love.

Separate work and personal apps It is initially glaring to see two icons on the home screen for the same app, but once you start using it you’ll wonder what you did without it. This is a fact I quickly realized when I picked up a different enrolled device and was constantly switching between work and personal accounts on the Microsoft OneNote app, accidentally saving my grocery list on my work OneNote account.

Here’s an example of how I use the separate apps. I have the Photos app in the work profile and a personal Photos app. My Photos app in the work profile is filled with pictures of whiteboard artwork from various meetings, and none of these pictures show up in my personal Photos app.

Once you start using it you’ll wonder what you did without it.

This is very helpful because I don’t see these whiteboard pictures as an option when I try to share media with my friends on WhatsApp (which is not in the work profile). However, when I open Slack (which is in the work profile), I can easily share the whiteboard photos with my colleagues. Similar reasoning applies for pictures of receipts I use for expense reporting in Concur.

It’s easy to tell what other business apps you can share with using work app badges, sharing restrictions and separate work notifications.

Get business apps on Play Google Play for Work allows businesses to securely deploy and manage apps across all users running Android for Work, simplifying the process of distributing apps to employees and ensuring that IT approves every deployed app.

Work quickly and effectively using the best work apps around. The entire catalog of Google Play premium business apps is available for download.

Turn off work This has got to be one of my favorite features with the work profile. It seems so unbelievably obvious and makes you wonder why all platforms don’t have it. You can TURN OFF NOTIFICATIONS FROM WORK APPS!

There is a handy toggle when you swipe down from the top, or through the Settings app. So when I am on vacation, I am not inundated with work email notifications and Slack messages.

With work mode in Android 7.0 Nougat, you can disable your work apps and hide work notifications on weekends, nights or any time you don’t want interruptions.

Use built-in business apps For everyday business tasks, we’ve created a suite of business apps for email, contacts and calendar, which supports both Exchange and Notes and provides document editing capabilities for documents, spreadsheets and presentations.

Android at work comes pre-installed with productivity apps from Google including email, contact, calendar, Docs, Sheets, and Slides.

How to Disable work profile
To disabled work profile just Tap on work profile toggle button to off and all work profile related apps will be disabled. For full detail, Click here.

How to Delete work profile
To deactivate Android Work Profile:

Navigate to Settings > Accounts on your device.
Click Remove work profile. (Here app is Company Profile)

Tap DELETE and proceed with the deactivation.

Once the deactivation is complete, navigate to the launcher of the device. Notice the disappearance of the applications with red icons.

For more detail to delete profile, Just click here.