Or visit the following link on your android to complete this offer

8 Steps to Google Pay on Android

Within our Android Apps we can use the Google Pay API to plugin a convenient way for our users to checkout in our app, without the need for them to enter any of their payment information (after an initial setup). This brings the user a collection of advantages such as:

• A centralised place to complete all their payments within your apps, just like they are able to do on the web or in stores
• A streamlined process when completing the checkout stage of a purchase from within your app
• A feeling of safety whilst paying due to the secure storage of payment information fro Google pay

The Google Pay API for android allows developers to easily integrate a payment method that provides this streamlined, secure and familiar experience for our users.

We all want to make things simpler and better or users, so in this article I want to show you can get Google Pay integrated into your Android Application with 8 individual steps.

Configure payment methods

Before we go ahead and start configuring the class used to handle payments within our app, we need to declare some fundamental data used in the requests that we are going to perform.

We begin by defining a list of accepted cards, this collection can currently include Amex, Discover, Mastercard, JCB and Visa cards.

Next we need to define the accepted authentication methods that can be used for the transaction. The given choice can include the following options:

• PAN_ONLY — Associated with cards that are stored alongside the Google Account of the current user. The data returned includes a corresponding account number alongside the expiration month and year.
• CRYPTOGRAM_3DS — Associated with cards that are stored as Android device tokens. The data returned includes a 3DS cryptogram generated on the given device.

Now that we have the above details defined, we can go ahead and prepare this data for use with the Google Pay API. These need to go under the following properties:

• allowedAuthMethods — Takes the accepted authentication methods that can be used when making payment requests
• allowedCardNetworks — Takes the declared accepted cards that can be used to make payments

As well as the above we can also optionally declare:

• allowPrepaidCards — States whether or not pre-paid cards can be used when making payment requests
• billingAddressRequired — States whether or not a billing address is required to complete the transaction
• billingAddressParameters — Takes data in the format of the BillingAddressParameters class

Finally, we put all of this together by declaring the accepted payment type as a CARD and pass over the payment parameters that we declared above:

Configure wallet options

Before we instantiate our payment client to handle our payment requests, we need to create an instance of the options used by this client — this is in the form of the WalletOptions class.

Using the builder we can configure two properties to be using by our payment client:

• environment —The environment to be used when making transactions. This will be set to either ENVIRONMENT_PRODUCTION or ENVIRONMENT_TEST.
• theme — The theme to be used for the payments widget. This will be set to either THEME_LIGHT or THEME_DARK.

Initialise the Payments Client

Now that we have configured the options for our payments client, we can go ahead an instantiate a new instance of our client ready for use.

Here we pass in our current context and the WalletOptions instance that we built during the last step. At this point we now have a payments client reference within our application that can be triggered when the uses requests to make a payment.

Declare a Google Play Button

Using the assets provided over on the brand guidelines for Google Pay, you need to begin by adding a button to your application that uses one of the provided assets. This provides a way for the user to recognise the Google Pay payment method. Selecting this button will trigger the payment flow that we will look at over the next few sections.

Check if payments is ready for use

Now that we have a payments client, we want to check if the user is able to make payments using the Google Pay API — we may encounter errors when trying to access the API otherwise. So here we want to make sure that the button for Google Pay is not visible until the Google Pay API is ready for use.

We begin by building the request that is to be sent for our isReadyToPay call. Here we pass:

• apiVersion — The major API version to be used (integer)
• apiVersionMinor — The minor API version to be used (integer)
• allowedPaymentMethods — A collection of PaymentMethod instances that declare the supported payment methods of the client.

We can also optionally provide a existingPaymentMethodRequired (boolean) property — setting this property to true will cause isReadyToPay() to return true if the user is ready to pay with at least one of the specified payment methods.

Now that we have these properties built, we can go ahead and pass them to our isReadyToPay() call:

Setup Gateway Configuration

Next we need to setup the relevant gateway details — this gateway is what will receive the encrypted users information to process a given transaction.

• gateway — Identify for a Google-supported gateway
• gatewayMerchantId — Unique ID that links the merchant to the given gateway

You’ll notice below that we then bundle this all together (marked with the PAYMENT_GATEWAY identifier) as the tokenizationSpecification argument for use by the Google Pay API.

Prepare transaction information

At this point we need to defined the transaction data that will be presented by the Google Pay widget. We begin with the TransactionInfo, this contains details such as:

• currencyCode — The currency to be used for the transaction
• totalPriceStatus — The status of the total price. This will be either NOT_CURRENTLY_KNOWN, ESTIMATED (the price may change based on shipping or tax calculations) or FINAL (the price will never change from the one currently displayed to the user)
• totalPrice — The total price of the transaction
• checkoutOption — Decides the behaviour used and text to be shown within the checkout button of the google pay sheet. This can be either DEFAULT (standard behaviour, the user will need to confirm transaction details) or COMPLETE_IMMEDIATE_PURCHASE (when the totalPriceStatus is final, the user will complete the purchase with no further action).

We then need to build the payment request using our transaction information that we just prepared. For this we build a PaymentDataRequest instance and populate the required data:

• apiVersion — The major API version to be used (integer)
• apiVersionMinor — The minor API version to be used (integer)
• merchantInfo — Information regarding the merchant in the form of a MerchantInfo class
• allowedPaymentMethods — A collection of PaymentMethod instances that declare the supported payment methods of the client.
• transactionInfo — Information about the transaction in the form of a TransactionInfo class
• emailRequired — States whether an email address is required to complete the transaction
• shippingAddressRequired — States whether a shipping address is required to complete the transaction
• shippingAddressParameters — Information about the shipping address in the form of a ShippingAddressParameters class

Listen for Payments callback

Now that the payment request has been made we need to listen for the result. The result of this request is returned to the calling source via the onActivityResult method with the resultCode that was initially passed in with the request.

Once we have the data back from the request we can make use of the PaymentData class from the Google Pay API to parse the result of the intent — giving us back an instance of this PaymentData class that contains billing information for the transaction.

Here this data is then converted into a JSON format so that it can be passed onto our payment processor. At this point we have carried out all of the required steps and our transaction is ready to be completed.

Conclusion

Hopefully from this quick post you can see just how little steps are required to integrate Google Pay into your Android application. Doing so allows us to implement a streamlined experience that is secure and gives a sense of familiarity to our users. Why not get started with Google Pay in your own Android applications today?

Источник

View Binding in Android

We have learnt that every time we need to access a view from our XML layout into our Java or Kotlin code, we must use findViewById(). It was okay for small/personal projects where we use 5 to 6 views in a layout. But for larger projects we have comparatively more views in a layout, and accessing each view using the same findViewById() is not really comfortable.

What is View Binding?

View binding is a feature that allows you to more easily write code that interacts with views. Once view binding is enabled in a module, it generates a binding class for each XML layout file present in that module

Simply put, this allows us to access the views from the layout file in a very simple way by linking variables of our Kotlin or Java code with the XML views. When a layout is inflated, it creates a Binding object, which contains all the XML views that are casted to the correct type. This makes it really easier for us since we can retrieve all views in one line of code.

Getting started with View Binding

1. Let’s start by enabling view binding in our project:

In build.gradle(:app) add the code in -> android

2. Before the onCreate() method, we create our binding object

3. Perform the following steps in onCreate() method:

• Call the inflate() method to create an instance of the binding class for the activity to use.
• Get reference to the root view
• Pass the root view to setContentView() [setContentView(binding.root)] instead of layout [setContentView(R.id.activity_main)]

4. To get reference of any view, we can use the binding object:

Using View Binding in Fragments

We follow the same steps:

1. Before the onCreateView() method, we create our binding object

2. Initialize our binding object in onCreateView()

3. To get reference of any view, we can use the binding object

Note: The name of the binding class is generated by converting the name of the XML file to camel case and adding the word “Binding” to the end. Similarly, the reference for each view is generated by removing underscores and converting the view name to camel case . For example, activity_main.xml becomes ActivityMainBinding, and you can access @id/text_view as binding.textView.

View binding has important advantages over using findViewById():

• Null safety: Since view binding creates direct references to views, there’s no risk of a null pointer exception due to an invalid view ID.
• Type safety: The fields in each binding class have types matching the views they reference in the XML file. This means that there’s no risk of a class cast exception.

Start using View Binding

If you’re intrigued by View Binding and want to learn more about it, here’s some resources for you to learn:

One-Liner ViewBinding Library

You would have noticed that to use View Binding, we need to call the static inflate() method included in the generated binding class ( which creates an instance of the binding class for the activity or fragment )

Yesterday I came across an awesome library that makes ViewBinding one-liner ( By removing the boilerplate code and easily set ViewBindings with a single line )

One-liner ViewBinding Library : [Click Here]

Источник

Troubleshooting for Link to Windows

How do I check I’m running the latest version of Link to Windows?

Updates will be installed automatically if this option is enabled on your Android device. To ensure a smooth experience we recommend updating to the latest version available. To check manually:

On your Android device:

Go to Settings > Advanced features > Link to Windows.

In the upper right-hand corner, select » . » (More) > About Link to Windows.

If an update is available, you should see a dialog. Tap Update.

Wait for the update to complete successfully, then close and reopen the Your Phone app.

What happened to my Your Phone Companion app icon after upgrading my phone to Android 10?

Following a recent update, you will no longer see the old app icon. Instead you will now see Link to Windows pre-installed on your device. Swipe downward from the top of your screen to reveal your Android Notification panel, then tap Link to Windows.

Alternatively, you can find it by visiting Settings > Advanced Features, or type Link to Windows in the search box in Settings.

I’m having issues with the Your Phone app when using Samsung DeX at the same time

Having both the Your Phone app and DeX open may cause issues with both apps. To ensure the best experience, only have one of these apps open at a time.

How do I update the Your Phone app from the Microsoft Store?

Open the Microsoft Store.

Search for Your Phone.

If an update is available to you, you will see an Update button. Select Update and wait for the update to complete successfully, then select Launch.

How do I update Your Phone Companion-Link to Windows from the Galaxy Store?

To update the app from the Galaxy Store:

Open the Galaxy Store app on your Android device.

In the Galaxy Store, tap the search icon and type “Your Phone Companion – Link to Windows.»

Tap on Your Phone Companion – Link to Windows to open the app listing.

Tap the Update button.

You also need to ensure Link to Windows is updated to the latest version too. To do this:

Go to Settings > Advanced features > Link to Windows

Tap the “…” (More) option

Tap on About Link to Windows.

Tap the Update button. You will be redirected to the Galaxy Store listing for the app. This time you will also see Link to Windows in the app update options. Tap Update.

Wait for the update to complete successfully and restart your Android device. Wait a few minutes, then close and reopen the Your Phone app on your PC.

Note: It can take a few minutes for the updates to be recognized by the app. If the Your Phone app is still in an “update state”, wait a few minutes, then restart your Android device. On your PC, close and reopen the Your Phone app.

Troubleshooting updates in Your Phone and Your Phone Companion — Link to Windows

It can take a few minutes for the updates to be recognized by the app. After you update, if the app is still blocked, restart your Android device. Then, wait a few minutes and close and reopen the Your Phone app.

Check that both your Android device and PC are on Wi-Fi. You will need to be connected to Wi-Fi in order to download updates.

Источник