SubscriptionsManager.java

/*
 Swisscom Safe Connect
 Copyright (C) 2014 Swisscom

 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
package com.swisscom.safeconnect.backend;

import android.app.Activity;
import android.os.Bundle;

import com.swisscom.safeconnect.BuildConfig;
import com.swisscom.safeconnect.billing.Inventory;
import com.swisscom.safeconnect.billing.PurchaseManager;
import com.swisscom.safeconnect.billing.SkuDetails;
import com.swisscom.safeconnect.model.PlumberResponse;
import com.swisscom.safeconnect.model.PlumberSubscriptionResponse;
import com.swisscom.safeconnect.model.PlumberSubscriptionResponseList;
import com.swisscom.safeconnect.model.Subscription;
import com.swisscom.safeconnect.utils.Config;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * Created by vadim on 03.10.14.
 */
public class SubscriptionsManager {
    public static final String KEY_SUBSCRIPTIONS = "SubscriptionsManager.subscriptions";
    public static final String KEY_CURRENT_SUBSCR = "SubscriptionsManager.current_subscription";

    private BackendConnector backendConnector;
    private PurchaseManager purchaseManager;
    private Subscription[] subscriptions;
    private Activity activity;
    private boolean getSubscriptionsFail = false;

    public SubscriptionsManager(Activity activity, Bundle savedInstanceState) {
        backendConnector = new BackendConnector(activity);
        this.activity = activity;

        if (savedInstanceState != null) {
            Object[] s =  (Object []) savedInstanceState.getSerializable(KEY_SUBSCRIPTIONS);
            if (s != null) {
                subscriptions = Arrays.copyOf(s, s.length, Subscription[].class);
            }
        }
    }

    public void onSaveInstanceState(Bundle outState) {
        outState.putSerializable(KEY_SUBSCRIPTIONS, subscriptions);
    }

    /**
     * initializes the purchase manager. Returns over callback SkuDetails about subscriptions
     * that are active on backend as well as on market
     * @param callback
     */
    public void init(final PurchaseManager.Callback<Subscription[]> callback){
        if (subscriptions == null) {
            backendConnector.getAvailableSubscriptions(Config.getInstance().getPhoneNumber(),
                    new BackendConnector.ResponseCallback<PlumberSubscriptionResponseList>() {
                        @Override
                        public void onRequestComplete(int statusCode, PlumberSubscriptionResponseList response) {
                            if (statusCode != 200) {
                                callback.onRequestFailed(0);
                                getSubscriptionsFail = true;
                                return;
                            }
                            final PlumberSubscriptionResponse[] ss = response.getSubscriptions();
                            Subscription[] backendSubscriptions = new Subscription[ss.length];
                            for (int i = 0; i < ss.length; i++) {
                                backendSubscriptions[i] = new Subscription(ss[i]);
                            }
                            final List<Subscription> availSubscr = new ArrayList<Subscription>(backendSubscriptions.length);

                            purchaseManager = new PurchaseManager(activity, backendSubscriptions);

                            // init purchase manager and query the inventory
                            purchaseManager.init(new PurchaseManager.Callback<PlumberResponse>() {
                                @Override
                                public void onRequestCompleted(PlumberResponse result) {
                                    purchaseManager.queryInventory(new PurchaseManager.Callback<Inventory>() {
                                        @Override
                                        public void onRequestCompleted(Inventory result) {
                                            // we need subscriptions that active on backend as well as
                                            // on play market
                                            for (PlumberSubscriptionResponse s : ss) {
                                                SkuDetails sd = result.getSkuDetails(s.getName());
                                                if (sd != null) {
                                                    availSubscr.add(new Subscription(sd, s));
                                                }
                                            }
                                            completeRequest(availSubscr);
                                        }

                                        @Override
                                        public void onRequestFailed(int errorCode) {
                                            getSubscriptionsFail = true;
                                        }
                                    });
                                }

                                @Override
                                public void onRequestFailed(int errorCode) {
                                    getSubscriptionsFail = true;
                                }
                            });
                        }

                        private void completeRequest(List<Subscription> availSubscr) {
                            subscriptions = new Subscription[availSubscr.size()];
                            availSubscr.toArray(subscriptions);
                            callback.onRequestCompleted(subscriptions);
                            getSubscriptionsFail = false;
                        }
                    }
            );
        } else {
            callback.onRequestCompleted(subscriptions);
        }
    }

    public Subscription[] getSubscriptions() {
        return subscriptions;
    }

    public void getOwnSubscription(final PurchaseManager.Callback<Subscription> callback) {
        if (subscriptions == null) {
            if (getSubscriptionsFail) callback.onRequestFailed(0);
            return;
        }

        backendConnector.getOwnSubscription(Config.getInstance().getPhoneNumber(),
                Config.getInstance().getDeviceId(),
                new BackendConnector.ResponseCallback<PlumberSubscriptionResponse>() {
                    @Override
                    public void onRequestComplete(int statusCode, PlumberSubscriptionResponse response) {
                        if (statusCode == 200) {
                            // try to find subscription in our list
                            for (Subscription s: subscriptions) {
                                if (s.getSku().equals(response.getName())) {
                                    callback.onRequestCompleted(new Subscription(s, response.getValidTill()));
                                    return;
                                }
                            }

                            // did not found active subscription, which means that some subscribtion
                            // got inactive on google play. We dont want to fail, so return what we can
                            callback.onRequestCompleted(new Subscription(response));
                        } else {
                            callback.onRequestFailed(statusCode);
                        }
                    }
                }
        );
    }

    public boolean isFailed() {
        return getSubscriptionsFail;
    }
}