X

Accedi

Accedi ora per confermare

Password dimenticata?

...o entra con Facebook:

Non hai ancora un accout su AndroidPIT? Registrati

Licenza dell'applicazione – Come fare

Prerequisiti

Utilizzi già LVL?

Se lavori già con la Android License Verification Library, la connessione con la biblioteca delle licenze AndroidPIT è estremamente semplice.

1.

Scaricare la biblioteca delle licenze AndroidPIT e collegala al tuo progetto.

2.

Cambia le due seguenti definizioni delle variabili di

    private LicenseCheckerCallback mLicenseCheckerCallback;
    private LicenseChecker mChecker;

a

    private IAndroidPitLicenseCheckerCallback mLicenseCheckerCallback;
    private AndroidPitLicenseChecker mChecker;

3.

Cambia la creazione del checker di

    mChecker = new LicenseChecker(
            this,
            new ServerManagedPolicy(
                    this,
                    new AESObfuscator(SALT, getPackageName(), deviceId)),
            GOOGLE_PUBLIC_KEY);

a

    mChecker = new AndroidPitLicenseChecker(
            this,
            getPackageName(),
            ANDROIDPIT_PUBLIC_KEY,
            new ServerManagedPolicy(
                    this,
                    new AESObfuscator(SALT, getPackageName(), deviceId)),
            GOOGLE_PUBLIC_KEY);

4.

Cambia le definizioni del tuo listener di (per esempio)

    class MyLicenseCheckerCallback implements LicenseCheckerCallback

a

    class MyLicenseCheckerCallback implements IAndroidPitLicenseCheckerCallback

5.

Cambia il tipo di parametro errorCode nel metodo applicationError di

    public void applicationError(ApplicationErrorCode errorCode)

a

    public void applicationError(AndroidPitLicenseCheckCode errorCode)

ed espandi il controllo degli errori con i codici di risposta AndroidPIT (vedi più in basso).

Quet'era! La chiamata al checker così come l'implementazione dei metodi di callback allow() e dontAllow() non devono essere modificati.

Mordi e fuggi

Il sistema di attribuzione delle licenze di AndroidPIT è molto simile a quello di Google. Per utilizzarlo collega l'Android License Verification Library (LVL) così come la Biblioteca delle licenze AndroidPIT al tuo progetto. Genera un AndroidPitLicenseChecker nel metodo onCreate della tua applicazione e assegnagli il grado di una classe che può implementare l'interfaccia IAndroidPitLicenseCheckerCallback. Oltre a questo, hai bisogno di un codice di licenza, che riceverai da AndroidPIT nel tuo profilo di sviluppatore.Un esempio dell'attività può essere questo:

import android.app.Activity;

public class LicensingTest extends Activity implements OnClickListener
{

    private final String ANDROIDPIT_PUBLIC_KEY = "rO0ABXNyABRqYX...;"

    private final Handler mHandler = new Handler();

    private IAndroidPitLicenseCheckerCallback mLicenseCheckerCallback;
    private AndroidPitLicenseChecker mChecker;

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

        mLicenseCheckerCallback = new MyLicenseCheckerCallback();
        mChecker = new AndroidPitLicenseChecker(
                this,
                getPackageName(),
                ANDROIDPIT_PUBLIC_KEY);

        setContentView(R.layout.main);

        mChecker.checkAccess(mLicenseCheckerCallback);
    }

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

    class MyLicenseCheckerCallback implements IAndroidPitLicenseCheckerCallback
    {

        @Override
        public void allow()
        {
            // TODO: Handle positive response
        }

        @Override
        public void dontAllow()
        {
            // TODO: Handle negative response
        }

        @Override
        public void applicationError(AndroidPitLicenseCheckCode errorCode)
        {
            // TODO: Handle application error
        }

    }

}

Oltre alla verifica della licenza da parte di AndroidPIT, la biblioteca consente anche la verifica della licenza nell'Android Market di Google. Per farlo, adatta la chiamata del costruttore dell'AndroidPitLicenseChecker, con il quale prendere la policy di Google e la Google Public Key. Per tutte le procedure successive di verifica della licenza nell'Android Market consulta la documentazione LVL. La definizione dell'interfaccia del costruttore corrispondente appare così:

/**
 * Creates the AndroidPitLicenseChecker with all data to check against the
 * AndroidPIT App Center and Google. Google is checked first. If it fails,
 * AndroidPIT App Center will be consulted.
 
 @param context
 *            the context of the application
 @param appPkgName
 *            the package id of the app
 @param androidPitPublicKey
 *            the developers public key at AndroidPIT
 @param googlePolicy
 *            policy for Google licensing - @see LVL documentation
 @param googlePublicKey
 *            public key for Google licensing - @see LVL documentation
 */
public AndroidPitLicenseChecker(
        final Context context,
        final String appPkgName,
        final String androidPitPublicKey,
        final Policy googlePolicy,
        final String googlePublicKey);

In dettaglio

Il sistema di attribuzione delle licenze AndroidPIT è un meccanismo basato sulla Android License Verification Library (LVL) per verificare la validità dell'istallazione di un'applicazione Android acquistata presso AndroidPIT. Per utilizzarla è necessaria una connessione internet dal dispositivo mobile al nostro server delle licenze. Inoltre sul dispositivo dell'utilizzatore deve essere installato l'AndroidPIT App Center e l'utilizzatore finale deve essere dotato di un conto valido su AndroidPIT.

L'applicazione verifica con l'aiuto dell'AndroidPIT Licensing Library nell'App Center se l'utilizzatore finale possiede una licenza valida per l'applicazione. L'App Center si collega con il server delle licenze e convalida l'acquisto dell'applicazione. La verifica nel server delle licenze ha luogo ad ogni avvio dell'applicazione, ma al massimo una volta al giorno. Verifiche intermedie forniscono l'ultimo valore restituito dal server delle licenze (l'intermezzo può essere modificato in qualsiasi momento senza preavviso).

Passo dopo passo

Questa guida passo dopo passo si basa sull'utilizzo dell'Eclipse ADT. Nel caso utilizzi agli strumenti di sviluppo, saranno probabilmente necessari altri passaggi.

Scarica l'AndroidPIT Licensing Library e l'Android License Verification Library (LVL) di Google e collegale come progetto Android nell'ADT. Per utilizzare la biblioteca delle licenze AndroidPIT è necessaria almeno la versione 4 di Android API che è stata introdotta con Android 1.6. Crea un progetto per la tua applicazione Android con l'aiuto del Wizzard ADT e inserisci androidpit-licensing-lib nelle proprietà sotto Android. Verifica se la biblioteca richiama in modo corretto l'Android License Verification Library (LVL).

Ricevo simboli irrisolti o non posso compilare la mia applicazione.

Verifica il percorso alla Google LVL e alla biblioteca delle licenze AndoidPIT nelle impostazioni del progetto Android. Devono corrispondere in tutti i percorsi del suo sistema di dati.

Application project settings

I parametri per la biblioteca delle licenze AndroidPIT dovrebbe apparire così:

Library project settings

Come collego la verifica della licenza nel mio codice?

Per collegare l'applicazione con la verifica della licenza sull'AndroidPIT App Center, genera nel metodo onCreate() un'istanza della classe MyLicenseCheckerCallback. Il costruttore si attende un'istanza del contesto, nel quale lavora generalmente l'attività che è stata generata.

mLicenseCheckerCallback = new MyLicenseCheckerCallback();
mChecker = new AndroidPitLicenseChecker(
          this, getPackageName(), ANDROIDPIT_PUBLIC_KEY);
mChecker.checkAccess(mLicenseCheckerCallback);

Inoltre, il costruttore si attende informazioni sul nome del pacchetto Android e un codice di licenza preparato da AndroidPIT. Il codice della licenza è una chiave pubblica codificata in base64, che può essere vista in qualsiasi momento nel profilo dello sviluppatore su AndroidPIT sotto Licenza.

Come ricevo le notifica dal server delle licenze?

La verifica della licenza viene avviata richiamando il metodo checkAccess() nell'AndroidPitLicenseChecker. Questo metodo si attende un oggetto di callback che implementa l'interfaccia IAndroidPitLicenseCheckerCallback. La classe deve essere adesso implementata e racchiude tre metodi come la classe nell'Android Market Licensing. Se la verifica della licenza è stata efficace, il metodo allow() richiama la biblioteca delle licenze AndroidPIT. Se la verifica ha dato esito negativo, viene richiamato dontAllow(). Gli errori vengono segnalati con il metodo applicationError(). In base ai tuoi desideri puoi impostare delle reazioni per tutti e tre i metodi.

class MyLicenseCheckerCallback implements IAndroidPitLicenseCheckerCallback
{

    @Override
    public void allow()
    {
        // TODO: Handle positive response
    }

    @Override
    public void dontAllow()
    {
        // TODO: Handle negative response
    }

    @Override
    public void applicationError(AndroidPitLicenseCheckCode errorCode)
    {
        // TODO: Handle application error
    }

}

Come posso verificare la licenza nell'Android Market?

Oltre alla verifica nella nostra biblioteca, esiste la possibilità di verificare la licenza presso Google. In questo caso mette a disposizione l'AndroidPitLicenseChecker di un secondo costruttore, che si attende una policy e la chiave pubblica di LVL. Bisogna consegnare entrambe. La verifica della licenza si realizza poi nella biblioteca. Richieste effettuate con successo vengono quietate con la chiamata del metodo allow(). I tentativi falliti si traducono in una richiesta supplementare al server delle licenze AndroidPIT. Se anche qui la verifica della licenza fornisce una risposta negativa, viene richiamato il metodo dontAllow().

L'esempio è basato sulla documentazione dal Google API.

mChecker = new AndroidPitLicenseChecker(
               this, 
               getPackageName()
               ANDROIDPIT_PUBLIC_KEY,
               new ServerManagedPolicy(
                   this,
                   new AESObfuscator(SALT, getPackageName(), deviceId)),
               GOOGLE_PUBLIC_KEY);

Come posso testare diversi messaggi d'errore da parte del server delle licenze?

Per testare la tua connessione puoi impostare una risposta fissa nel tuo profilo di sviluppatore. Questo è utile per verificare come reagisce la tua applicazione e trattare i diversi codici d'errore dal server delle licenze. Per farlo seleziona il valore appropriato nel menù a scorrimento sotto la chiave della licenza. Il server restituirà questo valore quando sei connesso nell'App Center con il tuo conto di sviluppatore.

Come disabilito la cache dei risultati nell'App Center?

L'App Center salva i risultati delle ultime richieste per un giorno, al massimo fino alla richiesta successiva al server delle licenze. Per disabilitare questo comportamento puoi impostare il checker delle licenze in una modalità debug. Per farlo devi richiamare il metodo setDebug(true). Questo disattiverà la cache e tutte le richieste verrano immediatamente inoltrate al server delle licenze. Ricorda di disattivare la modalità di debug quando pubblicherai la tua applicazione!

Che succede se l'utilizzatore finale non è connesso all'App Center?

Se nell'App Center non sono presenti le informazioni dell'utente, si aprirà nell'applicazione una finestra di dialogo che richiederà l'indirizzo e-mail e la password dell'utente.

Come posso essere sicuro che le richieste delle licenze abbiano raggiunto il server delle licenze?

La biblioteca delle licenze AndroidPIT contiene la classe AndroidPitSignedLicenseChecker. Questa classe consente la possibilità di verificare se la richiesta ha raggiunto il server delle licenze o no. Perciò la risposta viene marcata sul server con l'aiuto di una chiave privata dello sviluppatore. Nella biblioteca viene verificata la firma con l'AndroidPitLicenseingResponseValidator e controllato se il Salt, che è stato inviato con la richiesta, corrisponde con quello della risposta. Considera che non è disponibile nessun caching dello status della licenza nell'App Center. Ogni richiesta deve essere lavorata dal server delle licenze. Se l'utente non ha a disposizione una connessione internet, la biblioteca risponderà negativamente con ERROR_NOT_CONNECTED.

Un esempio del genere può apparire in questo modo:

AndroidPitSignedLicenseChecker mChecker;

[ ... ]

mChecker = new AndroidPitSignedLicenseChecker(
               this, 
               getPackageName()
               ANDROIDPIT_PUBLIC_KEY);

Posso utilizzare il mio validatore delle licenze personale? Desidero verificare la firma per conto mio.

Sì, è possibile. Per farlo implementa l'interfaccia ILicensingResponseValidator e assegna al costruttore dell'AndroidPitSignedLicenseChecker un'istanza della classe da implementare. La classe deve implementare due metodi. getSalt() deve rinviare ad un numero intero, che sarà rinviato al server nel frattempo che il Salt verifica le licenze. Questo salto deve essere memorizzato dalla richiesta alla risposta se ha un ruolo nel processo di validazione. Il metodo checkResponse() dovrebbe verificare la validità della risposta dei dati e in caso di errori ritornare AndroidPitLicenseCheckCode.NOT_LICENSED. In caso di validazione avvenuta con successo il metodo dovrebbe ritornare il codice di risposta del server. Come modello di implementazione puoi consultare l'AndroidPitLicensingResponseValidator nella biblioteca delle licenze AndroidPIT.

Il mio progetto no trova più l'enumerazione de.androidpit.AndroidPitLicenseCheckError.

L'enumerazione è stata rinominato in de.androidpit.AndroidPitLicenseCheckCode.

Come posso creare un oggetto di chiave pubblica basato sulla stringa base64?

Come probabilmente hai già visto, mettiamo a disposizione la chiave pubblica come stringa codificata in base64. Per verificare la firma della risposta del server, hai bisogno in ogni caso di un oggetto di chiave pubblica. Il codice seguente ti mostrare come ottenerlo da questa stringa.

    /**
     * Converts the base64 encoded representation of a public key into a
     * PublicKey object.
     */
    private PublicKey createPublicKey(String pubKeyBase64)
    {

        PublicKey pubKey = null;
        try
        {
            // the pub key comes in as a Base64 coded string. Decode to the
            // byte array which contains the object stream of the public key
            ByteArrayInputStream pubKeyByteArray = new ByteArrayInputStream(
                    Base64.decode(pubKeyBase64));
            ObjectInputStream publicKeyObject = new ObjectInputStream(
                    pubKeyByteArray);
            BigInteger modulus = (BigIntegerpublicKeyObject.readObject();
            BigInteger exponent = (BigIntegerpublicKeyObject.readObject();

            RSAPublicKeySpec keySpec = new RSAPublicKeySpec(modulus, exponent);
            KeyFactory rsaKeyFactory = KeyFactory.getInstance("RSA");
            pubKey = rsaKeyFactory.generatePublic(keySpec);
        }
        catch (Exception ex)
        {
            Log.e(
                    "LicenseResponseValidator",
                    "Deserialization of public key failed.",
                    ex);
        }
        return pubKey;
    }

Biblioteca delle licenze AndroidPIT

Se stai usando un licenza del vecchio Android Market (Pacchetto com.android.vending.licensing), per favore usa questa licenza AndroidPIT:
Biblioteca delle licenze AndroidPIT Version 1.3

Se stai usando la nuova libreria Google Play (pacchetto com.google.android.vending.licensing), usa la seguente versione della libreria delle licenze AndroidPIT:
Biblioteca delle licenze AndroidPIT Version 2.1