Esempio n. 1
0
  @Override
  public Map<GcmMessage, EmulatedGcmMessageIntentBuilder> getGcmMessagesMap() {
    Map<GcmMessage, EmulatedGcmMessageIntentBuilder> gcmMessagesMap = Maps.newHashMap();
    gcmMessagesMap.put(
        AndroidGcmMessage.SAMPLE_MESSAGE,
        new EmulatedGcmMessageIntentBuilder() {

          @Override
          public Intent buildIntent() {
            return new Intent();
          }
        });
    return gcmMessagesMap;
  }
Esempio n. 2
0
 @Override
 public Map<Class<? extends Server>, List<? extends Server>> getServersMap() {
   Map<Class<? extends Server>, List<? extends Server>> serversMap = Maps.newHashMap();
   serversMap.put(ApiServer.class, Lists.newArrayList(ApiServer.values()));
   return serversMap;
 }
Esempio n. 3
0
/** @author Maxi Rosson */
public class BillingManagerImpl implements BillingManager, ServiceConnection {

  private static final String TAG = BillingManagerImpl.class.getSimpleName();

  // This is the action we use to bind to the MarketBillingService.
  public static final String MARKET_BILLING_SERVICE_ACTION =
      "com.android.vending.billing.MarketBillingService.BIND";

  // The service connection to the remote MarketBillingService.
  private IMarketBillingService service;

  // The list of requests that are pending while we are waiting for the connection to the
  // MarketBillingService to be
  // established.
  private LinkedList<BillingRequest> pendingRequests = new LinkedList<BillingRequest>();

  // The list of requests that we have sent to the Google Play app but for which we have not yet
  // received a response
  // code. The Map is indexed by the request Id that each request receives when it executes.
  private Map<Long, BillingRequest> sentRequests = Maps.newHashMap();

  private Context context = AbstractApplication.get();

  /**
   * @see
   *     com.jdroid.android.billing.BillingManager#register(com.jdroid.android.billing.BillingListener)
   */
  @Override
  public synchronized void register(BillingListener billingListener) {
    BillingResponseHandler.register(billingListener);
  }

  /**
   * @see
   *     com.jdroid.android.billing.BillingManager#unregister(com.jdroid.android.billing.BillingListener)
   */
  @Override
  public synchronized void unregister(BillingListener billingListener) {
    BillingResponseHandler.unregister(billingListener);
  }

  /**
   * @see
   *     com.jdroid.android.billing.BillingManager#register(com.jdroid.android.billing.PurchaseObserver)
   */
  @Override
  public synchronized void register(PurchaseObserver purchaseObserver) {
    BillingResponseHandler.register(purchaseObserver);
  }

  /**
   * @see
   *     com.jdroid.android.billing.BillingManager#unregister(com.jdroid.android.billing.PurchaseObserver)
   */
  @Override
  public synchronized void unregister(PurchaseObserver purchaseObserver) {
    BillingResponseHandler.unregister(purchaseObserver);
  }

  /**
   * The base class for all requests that use the MarketBillingService. Each derived class overrides
   * the run() method to call the appropriate service interface. If we are already connected to the
   * MarketBillingService, then we call the run() method directly. Otherwise, we bind to the service
   * and save the request on a queue to be run later when the service is connected.
   */
  abstract class BillingRequest {

    public static final String BILLING_RESPONSE_REQUEST_ID = "REQUEST_ID";
    public static final String BILLING_RESPONSE_RESPONSE_CODE = "RESPONSE_CODE";
    public static final long BILLING_RESPONSE_INVALID_REQUEST_ID = -1;

    // These are the names of the fields in the request bundle.
    private static final String BILLING_REQUEST_METHOD = "BILLING_REQUEST";
    private static final String BILLING_REQUEST_API_VERSION = "API_VERSION";
    private static final String BILLING_REQUEST_PACKAGE_NAME = "PACKAGE_NAME";
    public static final String BILLING_REQUEST_NOTIFY_IDS = "NOTIFY_IDS";
    public static final String BILLING_REQUEST_NONCE = "NONCE";

    private long requestId;

    /**
     * Execute the request, starting the connection if necessary.
     *
     * @return true if the request was executed or queued; false if there was an error starting the
     *     connection
     */
    public boolean execute() {
      if (runIfConnected()) {
        return true;
      }

      if (bindToMarketBillingService()) {
        // Add a pending request to run when the service is connected.
        pendingRequests.add(this);
        return true;
      }
      return false;
    }

    /**
     * The derived class must implement this method.
     *
     * @throws RemoteException
     */
    protected abstract long doExecute() throws RemoteException;

    /**
     * Try running the request directly if the service is already connected.
     *
     * @return true if the request ran successfully; false if the service is not connected or there
     *     was an error when trying to use it
     */
    public boolean runIfConnected() {
      if (service != null) {
        try {
          requestId = doExecute();
          Log.d(TAG, "BillingRequest id: " + requestId);
          if (requestId >= 0) {
            sentRequests.put(requestId, this);
          }
          return true;
        } catch (RemoteException e) {
          onRemoteException(e);
        }
      }
      return false;
    }

    /**
     * Called when a remote exception occurs while trying to execute the {@link #doExecute()}
     * method. The derived class can override this to execute exception-handling code.
     *
     * @param e the exception
     */
    protected void onRemoteException(RemoteException e) {
      Log.w(TAG, "Remote billing service crashed");
      service = null;
    }

    /**
     * This is called when the Google Play app sends a response code for this request.
     *
     * @param responseCode the response code
     */
    protected void responseCodeReceived(BillingResponseCode responseCode) {
      // Do Nothing by default
    }

    protected Bundle makeRequestBundle(String method) {
      Bundle request = new Bundle();
      request.putString(BILLING_REQUEST_METHOD, method);
      request.putInt(BILLING_REQUEST_API_VERSION, 1);
      request.putString(BILLING_REQUEST_PACKAGE_NAME, AndroidUtils.getPackageName());
      return request;
    }

    protected void logResponseCode(String request, Bundle response) {
      BillingResponseCode responseCode = BillingResponseCode.valueOf(response);
      Log.i(TAG, request + " response code: " + responseCode);
    }
  }

  /** This request verifies that the Google Play app supports in-app billing. */
  private class CheckBillingSupported extends BillingRequest {

    private static final String CHECK_BILLING_SUPPORTED = "CHECK_BILLING_SUPPORTED";

    /** @see com.splatt.android.common.billing.BillingService.BillingRequest#doExecute() */
    @Override
    protected long doExecute() throws RemoteException {

      Log.d(TAG, "Checking if billing is supported");

      Bundle requestBundle = makeRequestBundle(CHECK_BILLING_SUPPORTED);
      Bundle responseBundle = service.sendBillingRequest(requestBundle);
      BillingResponseCode responseCode = BillingResponseCode.valueOf(responseBundle);
      Log.i(TAG, "CheckBillingSupported response code: " + responseCode);
      BillingResponseHandler.checkBillingSupportedResponse(responseCode);
      return BILLING_RESPONSE_INVALID_REQUEST_ID;
    }
  }

  /**
   * This request sends a purchase message to the Google Play app and is the foundation of in-app
   * billing. You send this request when a user indicates that he or she wants to purchase an item
   * in your application. The Google Play app then handles the financial transaction by displaying
   * the checkout user interface.
   */
  public class RequestPurchase extends BillingRequest {

    private static final String REQUEST_PURCHASE = "REQUEST_PURCHASE";
    private static final String BILLING_REQUEST_ITEM_ID = "ITEM_ID";
    private static final String BILLING_REQUEST_DEVELOPER_PAYLOAD = "DEVELOPER_PAYLOAD";
    private static final String BILLING_RESPONSE_PURCHASE_INTENT = "PURCHASE_INTENT";

    private Purchasable purchasable;

    private String developerPayload;

    public RequestPurchase(Purchasable purchasable) {
      this(purchasable, null);
    }

    public RequestPurchase(Purchasable purchasable, String developerPayload) {
      this.purchasable = purchasable;
      this.developerPayload = developerPayload;
    }

    @Override
    protected long doExecute() throws RemoteException {

      Log.d(TAG, "Requesting purchase for product id: " + purchasable.getProductId());

      Bundle request = makeRequestBundle(REQUEST_PURCHASE);
      request.putString(BILLING_REQUEST_ITEM_ID, purchasable.getProductId());
      // Note that the developer payload is optional.
      if (developerPayload != null) {
        request.putString(BILLING_REQUEST_DEVELOPER_PAYLOAD, developerPayload);
      }
      Bundle response = service.sendBillingRequest(request);
      PendingIntent pendingIntent = response.getParcelable(BILLING_RESPONSE_PURCHASE_INTENT);
      if (pendingIntent == null) {
        Log.e(TAG, "Error with requestPurchase for product id: " + purchasable.getProductId());
        return BILLING_RESPONSE_INVALID_REQUEST_ID;
      }

      BillingResponseHandler.startMarketCheckoutActivity(pendingIntent, new Intent());
      return response.getLong(BILLING_RESPONSE_REQUEST_ID, BILLING_RESPONSE_INVALID_REQUEST_ID);
    }

    @Override
    protected void responseCodeReceived(BillingResponseCode responseCode) {
      BillingResponseHandler.responseCodeReceived(this, responseCode);
    }
  }

  /**
   * This request acknowledges that your application received the details of a purchase state
   * change. The Google Play app sends purchase state change notifications to your application until
   * you confirm that you received them.
   */
  class ConfirmNotifications extends BillingRequest {

    private static final String CONFIRM_NOTIFICATIONS = "CONFIRM_NOTIFICATIONS";

    private final String[] notifyIds;

    public ConfirmNotifications(String[] notifyIds) {
      this.notifyIds = notifyIds;
    }

    @Override
    protected long doExecute() throws RemoteException {

      Log.d(TAG, "Confirming notifications for notification ids: " + notifyIds);

      Bundle request = makeRequestBundle(CONFIRM_NOTIFICATIONS);
      request.putStringArray(BILLING_REQUEST_NOTIFY_IDS, notifyIds);
      Bundle response = service.sendBillingRequest(request);
      logResponseCode("ConfirmNotifications", response);
      return response.getLong(BILLING_RESPONSE_REQUEST_ID, BILLING_RESPONSE_INVALID_REQUEST_ID);
    }
  }

  /**
   * This request retrieves the details of a purchase state change. A purchase changes state when a
   * requested purchase is billed successfully or when a user cancels a transaction during checkout.
   * It can also occur when a previous purchase is refunded. The Google Play app notifies your
   * application when a purchase changes state, so you only need to send this request when there is
   * transaction information to retrieve.
   */
  class GetPurchaseInformation extends BillingRequest {

    private static final String GET_PURCHASE_INFORMATION = "GET_PURCHASE_INFORMATION";

    private long nonce;

    private final String[] notifyIds;

    public GetPurchaseInformation(String[] notifyIds) {
      this.notifyIds = notifyIds;
    }

    @Override
    protected long doExecute() throws RemoteException {

      Log.d(TAG, "Getting purchase information for notification ids: " + notifyIds);

      nonce = Security.generateNonce();

      Bundle request = makeRequestBundle(GET_PURCHASE_INFORMATION);
      request.putLong(BILLING_REQUEST_NONCE, nonce);
      request.putStringArray(BILLING_REQUEST_NOTIFY_IDS, notifyIds);
      Bundle response = service.sendBillingRequest(request);
      logResponseCode("GetPurchaseInformation", response);
      return response.getLong(BILLING_RESPONSE_REQUEST_ID, BILLING_RESPONSE_INVALID_REQUEST_ID);
    }

    @Override
    protected void onRemoteException(RemoteException e) {
      super.onRemoteException(e);
      Security.removeNonce(nonce);
    }
  }

  /**
   * This request retrieves a user's transaction status for managed purchases. You should send this
   * request only when you need to retrieve a user's transaction status, which is usually only when
   * your application is reinstalled or installed for the first time on a device.
   */
  public class RestoreTransactions extends BillingRequest {

    private static final String RESTORE_TRANSACTIONS = "RESTORE_TRANSACTIONS";

    private long nonce;

    @Override
    protected long doExecute() throws RemoteException {

      Log.d(TAG, "Executing restore transactions");

      nonce = Security.generateNonce();

      Bundle request = makeRequestBundle(RESTORE_TRANSACTIONS);
      request.putLong(BILLING_REQUEST_NONCE, nonce);
      Bundle response = service.sendBillingRequest(request);
      logResponseCode("RestoreTransactions", response);
      return response.getLong(BILLING_RESPONSE_REQUEST_ID, BILLING_RESPONSE_INVALID_REQUEST_ID);
    }

    @Override
    protected void onRemoteException(RemoteException e) {
      super.onRemoteException(e);
      Security.removeNonce(nonce);
    }

    @Override
    protected void responseCodeReceived(BillingResponseCode responseCode) {
      BillingResponseHandler.responseCodeReceived(this, responseCode);
    }
  }

  /**
   * @see com.jdroid.android.billing.BillingManager#checkResponseCode(long,
   *     com.jdroid.android.billing.BillingResponseCode)
   */
  @Override
  public void checkResponseCode(long requestId, BillingResponseCode responseCode) {
    BillingRequest request = sentRequests.get(requestId);
    if (request != null) {
      Log.d(TAG, request.getClass().getSimpleName() + " response code: " + responseCode);
      request.responseCodeReceived(responseCode);
    }
    sentRequests.remove(requestId);
  }

  /**
   * Binds to the MarketBillingService and returns true if the bind succeeded.
   *
   * @return true if the bind succeeded; false otherwise
   */
  private boolean bindToMarketBillingService() {
    try {
      Log.i(TAG, "Binding to Market billing service");
      boolean bindResult = false;
      if (context != null) {
        bindResult =
            context.bindService(
                new Intent(MARKET_BILLING_SERVICE_ACTION), this, Context.BIND_AUTO_CREATE);
      }
      if (bindResult) {
        Log.i(TAG, "Market billing service bind successful.");
        return true;
      } else {
        Log.e(TAG, "Could not bind to Market billing service.");
      }
    } catch (SecurityException e) {
      Log.e(TAG, "Security exception: " + e);
    }
    return false;
  }

  /** @see com.jdroid.android.billing.BillingManager#checkBillingSupported() */
  @Override
  public boolean checkBillingSupported() {
    return new CheckBillingSupported().execute();
  }

  /**
   * @see
   *     com.jdroid.android.billing.BillingManager#requestPurchase(com.jdroid.android.billing.Purchasable,
   *     java.lang.String)
   */
  @Override
  public boolean requestPurchase(Purchasable purchasable, String developerPayload) {
    return new RequestPurchase(purchasable, developerPayload).execute();
  }

  /** @see com.jdroid.android.billing.BillingManager#restoreTransactions() */
  @Override
  public boolean restoreTransactions() {
    return new RestoreTransactions().execute();
  }

  /** @see com.jdroid.android.billing.BillingManager#confirmNotifications(java.lang.String[]) */
  @Override
  public boolean confirmNotifications(String... notifyIds) {
    return new ConfirmNotifications(notifyIds).execute();
  }

  /** @see com.jdroid.android.billing.BillingManager#getPurchaseInformation(java.lang.String[]) */
  @Override
  public boolean getPurchaseInformation(String[] notifyIds) {
    return new GetPurchaseInformation(notifyIds).execute();
  }

  /**
   * @see com.jdroid.android.billing.BillingManager#purchaseStateChanged(java.lang.String,
   *     java.lang.String)
   */
  @Override
  public void purchaseStateChanged(String signedData, String signature) {
    List<PurchaseOrder> orders = Security.verifyPurchase(signedData, signature);
    if ((orders != null) && !orders.isEmpty()) {
      BillingResponseHandler.notifyPurchaseStateChanged(orders);
    }
  }

  /**
   * This is called when we are connected to the MarketBillingService. This runs in the main UI
   * thread.
   *
   * @see android.content.ServiceConnection#onServiceConnected(android.content.ComponentName,
   *     android.os.IBinder)
   */
  @Override
  public void onServiceConnected(ComponentName name, IBinder binder) {
    Log.d(TAG, "MarketBillingService connected");
    service = IMarketBillingService.Stub.asInterface(binder);
    runPendingRequests();
  }

  /**
   * Runs any pending requests that are waiting for a connection to the service to be established.
   * This runs in the main UI thread.
   */
  private void runPendingRequests() {
    BillingRequest request;
    while ((request = pendingRequests.peek()) != null) {
      if (request.runIfConnected()) {
        // Remove the request
        pendingRequests.remove();
      } else {
        // The service crashed, so restart it. Note that this leaves the current request on the
        // queue.
        bindToMarketBillingService();
        return;
      }
    }
  }

  /**
   * This is called when we are disconnected from the MarketBillingService.
   *
   * @see android.content.ServiceConnection#onServiceDisconnected(android.content.ComponentName)
   */
  @Override
  public void onServiceDisconnected(ComponentName name) {
    Log.w(TAG, "Billing service disconnected");
    service = null;
  }

  /** @see com.jdroid.android.billing.BillingManager#bind(android.content.Context) */
  @Override
  public void bind(Context context) {
    this.context = context;
  }

  /** @see com.jdroid.android.billing.BillingManager#unbind() */
  @Override
  public void unbind() {
    try {
      context.unbindService(this);
      context = null;
    } catch (IllegalArgumentException e) {
      // This might happen if the service was disconnected
    }
  }
}