UltimateAndroidReference | Ultimate Android Reference | Android library

String mPath = Environment.getExternalStorageDirectory() + "/Print";
    Bitmap tmp = BitmapFactory.decodeFile(mPath);

 File imageFile = new File(mPath);


    FileOutputStream outStream;

    try
    {
        outStream = new FileOutputStream(imageFile);

        try
        {
            bitmap.compress(Bitmap.CompressFormat.JPEG, quality, outStream);
            outStream.flush();
            outStream.close();
        } catch (IOException e)
        {
            e.printStackTrace();
        }

    } catch (Exception e)
    {
        e.printStackTrace();
    }

<ImageView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_padding="20dp"
    android:scaleType="centerInside"
    android:src="@{model.isActive ? @drawable/activated_icon :@drawable/non_activated_icon}"/>

private val sp = PreferenceManager.getDefaultSharedPreferences(appContext)
fun consentedToPersonalizedAds() = sp.getString("IABTCF_VendorConsents", null) != "0"

try {

  AuthAccessToken authAccessToken = agcAuth.verifyAccessToken(accessToken, true);
} catch (AGCAuthException e) {
 if (e.getErrorCode() == AuthErrorCode.VERIFY_ACCESS_TOKEN_ACCESS_TOKEN_IS_NULL.getErrorCode()) {
     // The user access token is empty.
  } else if (e.getErrorCode() == AuthErrorCode.JWT_VERIFY_FAILED.getErrorCode()) {
     // Failed to authenticate the user access token.
  } else if (e.getErrorCode() == AuthErrorCode.JWT_EXPIRE.getErrorCode()) {
     // The user access token has expired.
  } else if (e.getErrorCode() == AuthErrorCode.JWT_REVOKED.getErrorCode()) {
     // The user access token has been revoked.
  } 

override fun <T : ViewModel?> create(modelClass: Class<T>): T {

override fun <T : ViewModel> create(modelClass: Class<T>): T {

val diff = resources.configuration.diff(vm.originalConfiguration)

Log.d("WallpaperCCTest", "matches CONFIG_ASSETS_PATHS? ${(diff.toLong() and 0x80000000) != 0L}")

implementation 'com.anjlab.android.iab.v3:library:1.1.0'

implementation 'com.android.billingclient:billing:4.0.0'

<string name="license_key">Place Your ID Here</string>
<string name="product_id">android.test.purchased</string>

import android.app.Activity
import android.content.Context
import android.widget.Toast
import com.android.billingclient.api.*
import java.io.IOException
import java.util.ArrayList

class InAppPurchase(context: Context) : PurchasesUpdatedListener{
    private val mContext: Context = context
    private var billingClient: BillingClient
    var ackPurchase =
        AcknowledgePurchaseResponseListener { billingResult ->
            if (billingResult.responseCode == BillingClient.BillingResponseCode.OK) {
                //if purchase is acknowledged
                // Grant entitlement to the user. and restart activity
                SharedPreferencesUtils.setPurchasedBillingValue(mContext, true)
                showMessage("Item Purchased")
                (mContext as Activity).recreate()
            }
        }

    init {
        billingClient =
            BillingClient.newBuilder(mContext).enablePendingPurchases().setListener(this).build()
        billingClient.startConnection(object : BillingClientStateListener {
            override fun onBillingSetupFinished(billingResult: BillingResult) {
                if (billingResult.responseCode == BillingClient.BillingResponseCode.OK) {
                    val queryPurchase = billingClient.queryPurchases(BillingClient.SkuType.INAPP)
                    val queryPurchases = queryPurchase.purchasesList
                    if (queryPurchases != null && queryPurchases.size > 0) {
                        handlePurchases(queryPurchases)
                    } else {
                        SharedPreferencesUtils.setPurchasedBillingValue(mContext, false)
                    }
                }
            }

            override fun onBillingServiceDisconnected() {}
        })
    }

    fun productPurchase() {
        //check if service is already connected
        if (billingClient.isReady) {
            initiatePurchase()
        } else {
            billingClient =
                BillingClient.newBuilder(mContext).enablePendingPurchases().setListener(this).build()
            billingClient.startConnection(object : BillingClientStateListener {
                override fun onBillingSetupFinished(billingResult: BillingResult) {
                    if (billingResult.responseCode == BillingClient.BillingResponseCode.OK) {
                        initiatePurchase()
                    } else {
                        showMessage("Error" + billingResult.debugMessage)
                    }
                }

                override fun onBillingServiceDisconnected() {}
            })
        }
    }

    private fun initiatePurchase() {
        val skuList: MutableList<String> = ArrayList()
        skuList.add(mContext.resources.getString(R.string.product_id))
        val params = SkuDetailsParams.newBuilder()
        params.setSkusList(skuList).setType(BillingClient.SkuType.INAPP)
        billingClient.querySkuDetailsAsync(
            params.build()
        ) { billingResult, skuDetailsList ->
            if (billingResult.responseCode == BillingClient.BillingResponseCode.OK) {
                if (skuDetailsList != null && skuDetailsList.size > 0) {
                    val flowParams = BillingFlowParams.newBuilder()
                        .setSkuDetails(skuDetailsList[0])
                        .build()
                    billingClient.launchBillingFlow(mContext as Activity, flowParams)
                } else {
                    //try to add item/product id "purchase" inside managed product in google play console
                    showMessage("Purchase Item not Found")
                }
            } else {
                showMessage(" Error " + billingResult.debugMessage)
            }
        }
    }

    /**
     * Verifies that the purchase was signed correctly for this developer's public key.
     *
     * Note: It's strongly recommended to perform such check on your backend since hackers can
     * replace this method with "constant true" if they decompile/rebuild your app.
     *
     */
    private fun verifyValidSignature(signedData: String, signature: String): Boolean {
        return try {
            // To get key go to Developer Console > Select your app > Development Tools > Services & APIs.
            val base64Key = mContext.getString(R.string.license_key)
            Security.verifyPurchase(base64Key, signedData, signature)
        } catch (e: IOException) {
            false
        }
    }

    fun handlePurchases(purchases: List<Purchase>) {
        for (purchase in purchases) {
            //if item is purchased
            if (mContext.getString(R.string.product_id) == purchase.skus[0] && purchase.purchaseState == Purchase.PurchaseState.PURCHASED) {
                if (!verifyValidSignature(purchase.originalJson, purchase.signature)) {
                    // Invalid purchase
                    // show error to user
                   showMessage("Invalid Purchase")
                    return
                }
//                 else purchase is valid
//                if item is purchased and not acknowledged
                if (!purchase.isAcknowledged) {
                    val acknowledgePurchaseParams = AcknowledgePurchaseParams.newBuilder()
                        .setPurchaseToken(purchase.purchaseToken)
                        .build()
                    billingClient.acknowledgePurchase(acknowledgePurchaseParams, ackPurchase)
                } else {
                    // Grant entitlement to the user on item purchase
                    // restart activity
                    if (!SharedPreferencesUtils.getPurchasedBillingValue(mContext)) {
                        SharedPreferencesUtils.setPurchasedBillingValue(mContext,true)
                        showMessage("Item Purchased")
                        (mContext as Activity).recreate()
                    }
                }
            } else if (mContext.getString(R.string.product_id) == purchase.skus[0] && purchase.purchaseState == Purchase.PurchaseState.PENDING) {
                showMessage("Purchase is Pending. Please complete Transaction")
            } else if (mContext.getString(R.string.product_id) == purchase.skus[0] && purchase.purchaseState == Purchase.PurchaseState.UNSPECIFIED_STATE) {
                SharedPreferencesUtils.setPurchasedBillingValue(mContext,false)
                showMessage("Purchase Status Unknown")
            }
        }


    }


    private fun showMessage(message: String) {
        (mContext as Activity).runOnUiThread{
            Toast.makeText(mContext, message, Toast.LENGTH_SHORT).show()
        }

    }

    override fun onPurchasesUpdated(billingResult: BillingResult, purchases: MutableList<Purchase>?) {
        //if item newly purchased
        if (billingResult.responseCode == BillingClient.BillingResponseCode.OK && purchases != null) {
            handlePurchases(purchases)
        } else if (billingResult.responseCode == BillingClient.BillingResponseCode.ITEM_ALREADY_OWNED) {
            val queryAlreadyPurchasesResult =
                billingClient.queryPurchases(BillingClient.SkuType.INAPP)
            val alreadyPurchases = queryAlreadyPurchasesResult.purchasesList
            alreadyPurchases?.let { handlePurchases(it) }
        } else if (billingResult.responseCode == BillingClient.BillingResponseCode.USER_CANCELED) {
            showMessage("Purchase Canceled")
        } else {
            showMessage("Error updated" + billingResult.debugMessage)
        }
    }


    fun onDestroyBilling() {
        billingClient.endConnection()
    }

}

import android.text.TextUtils
import android.util.Base64
import java.io.IOException
import java.security.*
import java.security.spec.InvalidKeySpecException
import java.security.spec.X509EncodedKeySpec

/**
 * Security-related methods. For a secure implementation, all of this code should be implemented on
 * a server that communicates with the application on the device.
 */
object Security {

    private const val KEY_FACTORY_ALGORITHM = "RSA"
    private const val SIGNATURE_ALGORITHM = "SHA1withRSA"

    /**
     * Verifies that the data was signed with the given signature, and returns the verified
     * purchase.
     * @param base64PublicKey the base64-encoded public key to use for verifying.
     * @param signedData the signed JSON string (signed, not encrypted)
     * @param signature the signature for the data, signed with the private key
     * @throws IOException if encoding algorithm is not supported or key specification
     * is invalid
     */
    @Throws(IOException::class)
    fun verifyPurchase(
        base64PublicKey: String, signedData: String,
        signature: String
    ): Boolean {
        if (TextUtils.isEmpty(signedData) || TextUtils.isEmpty(base64PublicKey)
            || TextUtils.isEmpty(signature)
        ) {
            //Purchase verification failed: missing data
            return false
        }
        val key = generatePublicKey(base64PublicKey)
        return verify(key, signedData, signature)
    }

    /**
     * Generates a PublicKey instance from a string containing the Base64-encoded public key.
     *
     * @param encodedPublicKey Base64-encoded public key
     * @throws IOException if encoding algorithm is not supported or key specification
     * is invalid
     */
    @Throws(IOException::class)
    fun generatePublicKey(encodedPublicKey: String): PublicKey {
        return try {
            val decodedKey = Base64.decode(encodedPublicKey, Base64.DEFAULT)
            val keyFactory = KeyFactory.getInstance(KEY_FACTORY_ALGORITHM)
            keyFactory.generatePublic(X509EncodedKeySpec(decodedKey))
        } catch (e: NoSuchAlgorithmException) {
            // "RSA" is guaranteed to be available.
            throw RuntimeException(e)
        } catch (e: InvalidKeySpecException) {
            val msg = "Invalid key specification: $e"
            throw IOException(msg)
        }
    }

    /**
     * Verifies that the signature from the server matches the computed signature on the data.
     * Returns true if the data is correctly signed.
     *
     * @param publicKey public key associated with the developer account
     * @param signedData signed data from server
     * @param signature server signature
     * @return true if the data and signature match
     */
    private fun verify(publicKey: PublicKey, signedData: String, signature: String): Boolean {
        val signatureBytes: ByteArray = try {
            Base64.decode(signature, Base64.DEFAULT)
        } catch (e: IllegalArgumentException) {
            //Base64 decoding failed
            return false
        }
        try {
            val signatureAlgorithm = Signature.getInstance(SIGNATURE_ALGORITHM)
            signatureAlgorithm.initVerify(publicKey)
            signatureAlgorithm.update(signedData.toByteArray())
            return signatureAlgorithm.verify(signatureBytes)
        } catch (e: NoSuchAlgorithmException) {
            // "RSA" is guaranteed to be available
            throw RuntimeException(e)
        } catch (e: InvalidKeyException) {
            //Invalid key specification
        } catch (e: SignatureException) {
            //Signature exception
        }
        return false
    }

}

var inAppPurchase: InAppPurchase  = InAppPurchase(this)
btnInApp.setOnClickListener {
            inAppPurchase.productPurchase()
        }