Android Licensing check with no server/service available

Question

I have an app and I am attempting to add the google licensing instead of the copy right protection.

My issue is: When the device can connect there is no issue and if there is a license then it grants the access. If the device can connect and there is no license then it denies access.

BUT when the device can NOT connect because of airplane mode, dead zone, etc, the app gives the not licensed response.

Here is my code: package "package name";

import android.app.Activity;
import android.app.AlertDialog;
import android.app.Dialog;
import android.content.DialogInterface;
import android.content.Intent;
import android.net.Uri;
import android.os.Bundle;
import android.provider.Settings.Secure;
import android.widget.Toast;

import com.android.vending.licensing.AESObfuscator;
import com.android.vending.licensing.LicenseChecker;
import com.android.vending.licensing.LicenseCheckerCallback;
import com.android.vending.licensing.ServerManagedPolicy;


public class LicenseCheck extends Activity {
    private class MyLicenseCheckerCallback implements LicenseCheckerCallback {

        @Override
        public void allow() {
            if (isFinishing()) {
                // Don't update UI if Activity is finishing.
                return;
            }
            // Should allow user access.
            startMainActivity();

        }


        @Override
        public void applicationError(ApplicationErrorCode errorCode) {
            if (isFinishing()) {
                // Don't update UI if Activity is finishing.
                return;
            }
            // This is a polite way of saying the developer made a mistake
            // while setting up or calling the license checker library.
            // Please examine the error code and fix the error.
            toast("Error: " + errorCode.name());
            startMainActivity();

        }

        @Override
        public void dontAllow() {
            if (isFinishing()) {
                // Don't update UI if Activity is finishing.
                return;
            }

            // Should not allow access. In most cases, the app should assume
            // the user has access unless it encounters this. If it does,
            // the app should inform the user of their unlicensed ways
            // and then either shut down the app or limit the user to a
            // restricted set of features.
            // In this example, we show a dialog that takes the user to Market.
            showDialog(0);
        }
    }



    private static final String BASE64_PUBLIC_KEY =     "MY KEY";

private static final byte[] SALT = new byte[] { "20 RANDOM INTEGERS"  };
private LicenseChecker mChecker;

// A handler on the UI thread.

private LicenseCheckerCallback mLicenseCheckerCallback;

private void doCheck() {

    mChecker.checkAccess(mLicenseCheckerCallback);
}

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    // Try to use more data here. ANDROID_ID is a single point of attack.
    String deviceId = Secure.getString(getContentResolver(),
            Secure.ANDROID_ID);

    // Library calls this when it's done.
    mLicenseCheckerCallback = new MyLicenseCheckerCallback();
    // Construct the LicenseChecker with a policy.
    mChecker = new LicenseChecker(this, new ServerManagedPolicy(this,
            new AESObfuscator(SALT, getPackageName(), deviceId)),
            BASE64_PUBLIC_KEY);
    doCheck();

}

@Override
protected Dialog onCreateDialog(int id) {
    // We have only one dialog.
    return new AlertDialog.Builder(this)
            .setTitle("Application Not Licensed")
            .setCancelable(false)
            .setMessage(
                    "This application is not licensed. Please purchase it from the Android Market")
            .setPositiveButton("Buy App",
                    new DialogInterface.OnClickListener() {
                        @Override
                        public void onClick(DialogInterface dialog,
                                int which) {
                            Intent marketIntent = new Intent(
                                    Intent.ACTION_VIEW,
                                    Uri.parse("http://market.android.com/details?id="
                                            + getPackageName()));
                            startActivity(marketIntent);
                            finish();
                        }
                    })
            .setNegativeButton("Exit",
                    new DialogInterface.OnClickListener() {
                        @Override
                        public void onClick(DialogInterface dialog,
                                int which) {
                            finish();
                        }
                    }).create();
}

@Override
protected void onDestroy() {
    super.onDestroy();
    mChecker.onDestroy();
}

private void startMainActivity() {
    startActivity(new Intent(this, MY_Activity.class));  
    finish();
}

public void toast(String string) {
    Toast.makeText(this, string, Toast.LENGTH_SHORT).show();
}

}

I am even willing to only block access if it only comes back NO License. I would much rather check each time the app runs and the server is available. Even if I could run a check to see if it can reach the server and go from there.

Answer 1

public void dontAllow(int policyReason) {

   if (isFinishing()) {
       // Don't update UI if Activity is finishing.
       return;
    }

    if (policyReason == Policy.RETRY) {
        //-- no connection (unable to validate license).
    } else { 
        //-- no license (application is not licensed).
    }

    showDialog(0);
}

Answer 2

You are probably using a test account with the LVL library. When using a Google Test account the license will be valid for only 1 minute, after the minute is up, any further license checks will require net access to return a valid response. With a real account that purchased the app, a valid license response would be cached for a number of days (assuming you are using the ServerManagedPolicy).

Answer 3

I found a work around. I did not find a fix. After exhaustive research, I have discovered that by default if there is no connectivity or in airplane mode the licensing check automatically defaults to NOT_LICENSED.

What I did was check for connectivity. If there is connectivity it runs the license check. If no connectivity it just goes to the Main Activity.