linphone-iphone/Classes/InAppProductsManager.m

/* InAppProductsManager.h
 *
 * Copyright (C) 2012  Belledonne Comunications, Grenoble, France
 *
 *  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 2 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, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#import "InAppProductsManager.h"

// In app purchase are not supported by the Simulator
#import <XMLRPCConnection.h>
#import <XMLRPCConnectionManager.h>
#import <XMLRPCResponse.h>
#import <XMLRPCRequest.h>

#import "Utils.h"
#import "LinphoneManager.h"

#import "PhoneMainView.h"
#import "InAppProductsViewController.h"

@interface InAppProductsManager()
	@property (retain, nonatomic) NSDictionary *accountCreationData;
	// needed because request:didFailWithError method is already used by SKProductsRequestDelegate...
	@property (nonatomic, retain) InAppProductsXMLRPCDelegate *xmlrpc;
@end

@implementation InAppProductsManager

// LINPHONE_CAPABILITY_INAPP_PURCHASE must be defined in Linphone Build Settings
#if LINPHONE_CAPABILITY_INAPP_PURCHASE && !TARGET_IPHONE_SIMULATOR

- (instancetype)init {
	if ((self = [super init]) != nil) {
		_enabled = (([[[UIDevice currentDevice] systemVersion] floatValue] >= 7.0) && ([SKPaymentQueue canMakePayments]) && ([[LinphoneManager instance] lpConfigBoolForKey:@"enabled" forSection:@"in_app_purchase"]));
		_initialized = false;
		_available = false;

		if (_enabled) {
			self.xmlrpc = [[InAppProductsXMLRPCDelegate alloc] init];
			_status = kIAPNotReady;
			[[SKPaymentQueue defaultQueue] addTransactionObserver:self];
			[self loadProducts];
		}
	}
	return self;
}

#pragma mark Public API

- (BOOL)isPurchasedWithID:(NSString *)productID {
	if (!_enabled) return FALSE;

	for (NSString *prod in _productsIDPurchased) {
		if ([prod isEqual: productID]) {
			bool isBought = true;
			LOGE(@"%@ is %s bought.", prod, isBought?"":"NOT");
			return isBought;
		}
	}
	return false;
}

- (BOOL)purchaseWitID:(NSString *)productID {
	if (!_enabled||!_initialized||!_available) {
		NSDictionary* dict = @{@"product_id":productID, @"error_msg": NSLocalizedString(@"In apps not ready yet", nil)};
		[self postNotificationforStatus:kIAPPurchaseFailed withDict:dict];
		return FALSE;
	}
	SKProduct *prod = [self productIDAvailable:productID];
	if (prod) {
		NSDictionary* dict = @{@"product_id": productID};
		[self postNotificationforStatus:kIAPPurchaseTrying withDict:dict];
		SKMutablePayment *payment = [SKMutablePayment paymentWithProduct:prod];
		_available = false;
		[[SKPaymentQueue defaultQueue] addPayment:payment];
		[[SKPaymentQueue defaultQueue] addTransactionObserver:self];
		return TRUE;
	} else {
		NSDictionary* dict = @{@"product_id": productID, @"error_msg": @"Product not available"};
		[self postNotificationforStatus:kIAPPurchaseFailed withDict:dict];
		return FALSE;
	}
}

- (BOOL)purchaseAccount:(NSString *)phoneNumber withPassword:(NSString *)password andEmail:(NSString*)email {
	if (phoneNumber) {
		NSString* productID = [[LinphoneManager instance] lpConfigStringForKey:@"paid_account_id" forSection:@"in_app_purchase"];
		self.accountCreationData = @{ @"phoneNumber":[phoneNumber retain], @"password":[password retain], @"email":[email retain] };

		if (![self purchaseWitID:productID]) {
			self.accountCreationData = nil;
		}
		return true;
	}
	return false;
}

-(BOOL)restore {
	if (!_enabled||!_initialized||!_available) {
		NSDictionary* dict = @{@"error_msg": NSLocalizedString(@"In apps not ready yet", nil)};
		[self postNotificationforStatus:kIAPRestoreFailed withDict:dict];
		return FALSE;
	}
	LOGI(@"Restoring user purchases...");
	//force new query of our server
	latestReceiptMD5 = nil;
	_available = false;
	[[SKPaymentQueue defaultQueue] restoreCompletedTransactions];
	return TRUE;
}

- (BOOL)retrievePurchases {
	if (!_enabled|!_initialized|!_available) {
		NSDictionary* dict = @{@"error_msg": NSLocalizedString(@"In apps not ready yet", nil)};
		[self postNotificationforStatus:kIAPRestoreFailed withDict:dict];
		return FALSE;
	} else if ([[self getPhoneNumber] length] == 0) {
		LOGW(@"Not retrieving purchase since not account configured yet");
		return FALSE;
	} else {
		_available = false;
		[self validateReceipt:nil];
		return TRUE;
	}
}

#pragma mark ProductListLoading

- (void)loadProducts {
	NSArray * list = [[[[LinphoneManager instance] lpConfigStringForKey:@"products_list" forSection:@"in_app_purchase"] stringByReplacingOccurrencesOfString:@" " withString:@""] componentsSeparatedByString:@","];

	_productsIDPurchased = [[NSMutableArray alloc] initWithCapacity:0];

	SKProductsRequest *productsRequest = [[SKProductsRequest alloc] initWithProductIdentifiers:[NSSet setWithArray:list]];
	productsRequest.delegate = self;
	[productsRequest start];
}

- (void)productsRequest:(SKProductsRequest *)request
	 didReceiveResponse:(SKProductsResponse *)response {
	_productsAvailable = [[NSMutableArray arrayWithArray: response.products] retain];

	LOGI(@"Found %lu products available", (unsigned long)_productsAvailable.count);
	_initialized = true;
	if (response.invalidProductIdentifiers.count > 0) {
		for (NSString *invalidIdentifier in response.invalidProductIdentifiers) {
			LOGW(@"Found product Identifier with invalid ID '%@'", invalidIdentifier);
		}
	} else {
		_available = true;
		[self postNotificationforStatus:kIAPReady withDict:nil];
	}
}

- (void)request:(SKRequest *)request didFailWithError:(NSError *)error {
	LOGE(@"Impossible to retrieve list of products: %@", [error localizedDescription]);
	//well, let's retry...
	[self loadProducts];
}

#pragma mark Other

- (SKProduct*) productIDAvailable:(NSString*)productID {
	if (!_enabled||!_initialized) return nil;
	for (SKProduct *product in _productsAvailable) {
		if ([product.productIdentifier compare:productID options:NSLiteralSearch] == NSOrderedSame) {
			return product;
		}
	}
	return nil;
}

- (void)requestDidFinish:(SKRequest *)request {
	if([request isKindOfClass:[SKReceiptRefreshRequest class]]) {
		NSURL *receiptUrl = [[NSBundle mainBundle] appStoreReceiptURL];
		if ([[NSFileManager defaultManager] fileExistsAtPath:[receiptUrl path]]) {
			LOGI(@"App Receipt exists");
			[self validateReceipt:nil];
		} else {
			// This can happen if the user cancels the login screen for the store.
			// If we get here it means there is no receipt and an attempt to get it failed because the user cancelled the login.
			LOGF(@"Receipt request done but there is no receipt");
		}
	}
}

- (void)validateReceipt: (SKPaymentTransaction*)transaction {
	NSString *receiptBase64 = nil;
	NSURL *receiptURL = [[NSBundle mainBundle] appStoreReceiptURL];

	// Test whether the receipt is present at the above URL
	if(![[NSFileManager defaultManager] fileExistsAtPath:[receiptURL path]]) {
		// We are probably in sandbox environment, trying to retrieve it...
		SKRequest* req = [[SKReceiptRefreshRequest alloc] init];
		LOGI(@"Receipt not found yet, trying to retrieve it...");
		req.delegate = self;
		[req start];
		return;
	}

	receiptBase64 = [[NSData dataWithContentsOfURL:receiptURL] base64EncodedStringWithOptions:0];
	LOGI(@"Found appstore receipt %@", [receiptBase64 md5]);

	//only check the receipt if it has changed
	if (latestReceiptMD5 == nil || ![latestReceiptMD5 isEqualToString:[receiptBase64 md5]]) {
		// We must validate the receipt on our server
		NSURL *URL = [NSURL URLWithString:[[LinphoneManager instance] lpConfigStringForKey:@"receipt_validation_url" forSection:@"in_app_purchase"]];

		XMLRPCRequest *request = [[XMLRPCRequest alloc] initWithURL: URL];

		// transaction is null when restoring user purchases at application start or if user clicks the "restore" button
		if (!transaction || [transaction.payment.productIdentifier isEqualToString:[[LinphoneManager instance] lpConfigStringForKey:@"paid_account_id" forSection:@"in_app_purchase"]]) {
			//buying for the first time: need to create the account
			//if ([transaction.transactionIdentifier isEqualToString:transaction.originalTransaction.transactionIdentifier]) {
			if (self.accountCreationData.count == 3) {
				[request setMethod: @"create_account_from_in_app_purchase" withParameters:[NSArray arrayWithObjects:
																						   @"",
																						   [_accountCreationData objectForKey:@"phoneNumber"],
																						   receiptBase64,
																						   @"",
																						   @"apple",
																						   [_accountCreationData objectForKey:@"email"],
																						   nil]];
				self.accountCreationData = nil;
				// otherwise simply renewing
			} else {
				if ([[self getPhoneNumber] length] > 0) {
				[request setMethod: @"get_expiration_date" withParameters:[NSArray arrayWithObjects:
																		   [self getPhoneNumber],
																		   receiptBase64,
																		   @"",
																		   @"apple",
																		   nil]];
				} else {
					LOGW(@"No SIP URI configured, doing nothing");
					_available = true;
					return;
				}
			}
		} else {
			LOGE(@"Hum, not handling product with ID %@", transaction.payment.productIdentifier);
			_available = true;
			return;
		}

		latestReceiptMD5 = [[receiptBase64 md5] retain];

		XMLRPCConnectionManager *manager = [XMLRPCConnectionManager sharedManager];
		[manager spawnConnectionWithXMLRPCRequest: request delegate: self.xmlrpc];
		LOGI(@"XMLRPC query %@: %@", [request method], [request body]);
		[request release];
	} else {
		LOGW(@"Not checking receipt since it has already been done!");
		_available = true;
	}
}

- (NSString*)getPhoneNumber {
	NSString * phoneNumber = @"";
	LinphoneProxyConfig *config = linphone_core_get_default_proxy_config([LinphoneManager getLc]);
	if (config) {
		const char *identity = linphone_proxy_config_get_identity(config);
		if (identity) {
			LinphoneAddress *addr = linphone_address_new(identity);
			if (addr) {
				phoneNumber = [NSString stringWithUTF8String:linphone_address_get_username(addr)];
				linphone_address_destroy(addr);
			}
		}
	}
	return phoneNumber;
}

- (void)paymentQueue:(SKPaymentQueue *)queue updatedTransactions:(NSArray *)transactions {
	for(SKPaymentTransaction * transaction in transactions) {
		switch (transaction.transactionState) {
			case SKPaymentTransactionStatePurchasing:
				break;
			case SKPaymentTransactionStatePurchased:
			case SKPaymentTransactionStateRestored: {
				if (!_initialized) {
					LOGW(@"Pending transactions before end of initialization, not verifying receipt");
				} else {
					[self validateReceipt: transaction];
				}
				[[SKPaymentQueue defaultQueue] finishTransaction:transaction];
				break;
			}
			case SKPaymentTransactionStateDeferred:
				LOGI(@"Waiting for parent approval...");
				//could do some UI stuff
				break;
			case SKPaymentTransactionStateFailed: {
				_available = true;
				[[SKPaymentQueue defaultQueue] finishTransaction:transaction];
				if (transaction.error.code == SKErrorPaymentCancelled) {
					LOGI(@"SKPaymentTransactionStateFailed: cancelled");
					NSDictionary* dict = @{@"product_id": transaction.payment.productIdentifier};
					[self postNotificationforStatus:kIAPPurchaseCancelled withDict:dict];
				} else {
					NSString* errlast = [NSString stringWithFormat:@"Purchase of %@ failed: %@.",transaction.payment.productIdentifier,transaction.error.localizedDescription];
					LOGE(@"SKPaymentTransactionStateFailed: %@", errlast);
					NSDictionary* dict = @{@"product_id": transaction.payment.productIdentifier, @"error_msg": errlast};
					[self postNotificationforStatus:kIAPPurchaseFailed withDict:dict];
				}
				break;
			}
		}
	}
}

- (void)paymentQueue:(SKPaymentQueue *)queue removedTransactions:(NSArray *)transactions {
	for(SKPaymentTransaction * transaction in transactions) {
		LOGI(@"%@ was removed from the payment queue.", transaction.payment.productIdentifier);
	}
}

- (void)paymentQueue:(SKPaymentQueue *)queue restoreCompletedTransactionsFailedWithError:(NSError *)error {
	if (error.code != SKErrorPaymentCancelled) {
		NSDictionary* dict = @{@"error_msg": [error localizedDescription]};
		[self postNotificationforStatus:kIAPRestoreFailed withDict:dict];
	}
}

- (void)paymentQueueRestoreCompletedTransactionsFinished:(SKPaymentQueue *)queue {
	LOGI(@"All restorable transactions have been processed by the payment queue.");
}

-(void)postNotificationforStatus:(IAPPurchaseNotificationStatus)status withDict:(NSDictionary*)dict {
	_status = status;
	LOGI(@"Triggering notification for status %@", status);
	[[NSNotificationCenter defaultCenter] postNotificationName:status object:self userInfo:dict];
}

- (void)XMLRPCRequest:(XMLRPCRequest *)request didReceiveResponse:(XMLRPCResponse *)response {
	if (!_enabled) return;

	_available = true;

	LOGI(@"XMLRPC response %@: %@", [request method], [response body]);
	NSString* productID = [[LinphoneManager instance] lpConfigStringForKey:@"paid_account_id" forSection:@"in_app_purchase"];

	// validation succeeded
	if(! [response isFault] && [response object] != nil) {
		if(([[request method] isEqualToString:@"get_expiration_date"])
		   || ([[request method] isEqualToString:@"create_account_from_in_app_purchase"])) {
			[_productsIDPurchased removeObject:productID];
			// response object can either be expiration date (long long number or an error string)
			double timeinterval = [[response object] doubleValue];
			if (timeinterval != 0.0f) {
				NSDate *expirationDate = [NSDate dateWithTimeIntervalSince1970:timeinterval/1000];
				NSDate *now = [[NSDate alloc] init];
				NSDictionary* dict = @{@"product_id": productID, @"expires_date": expirationDate};
				if ([expirationDate earlierDate:now] == expirationDate) {
					LOGW(@"Account has expired");
					[self postNotificationforStatus:kIAPPurchaseExpired withDict:dict];
				} else {
					[_productsIDPurchased addObject:productID];
					[self postNotificationforStatus:kIAPPurchaseSucceeded withDict:dict];
				}
			} else {
				NSString *error = [response object];
				LOGE(@"Failed with error %@", error);
				NSString *errorMsg;
				if ([error isEqualToString:@"ERROR_ACCOUNT_ALREADY_EXISTS"]) {
					errorMsg=NSLocalizedString(@"You have already registered an account.", nil);
				} else if ([error isEqualToString:@"ERROR_ACCOUNT_DOESNT_EXIST"]) {
					errorMsg=NSLocalizedString(@"You have already purchased an account but it does not exist anymore.", nil);
				} else if ([error isEqualToString:@"ERROR_PURCHASE_CANCELLED"]) {
					errorMsg=NSLocalizedString(@"You cancelled your account.", nil);
				} else {
					errorMsg=[NSString stringWithFormat:NSLocalizedString(@"Unknown error (%@).", nil), error];
				}
				NSDictionary* dict = @{@"product_id": productID, @"error_msg": NSLocalizedString(errorMsg, nil)};
				[self postNotificationforStatus:kIAPPurchaseFailed withDict:dict];
			}
		}
	} else {
		NSString *errorString = NSLocalizedString(@"Unknown error", nil);
		if ([response isFault]) {
			errorString = [NSString stringWithFormat:NSLocalizedString(@"Communication issue (%@)", nil), [response faultString]];
		} else if([response object] == nil) {
			errorString = NSLocalizedString(@"Invalid server response", nil);
		}
		LOGE(@"Communication issue (%@)", [response faultString]);
		UIAlertView* errorView = [[UIAlertView alloc] initWithTitle:NSLocalizedString(@"Communication issue",nil)
															message:errorString
														   delegate:nil
												  cancelButtonTitle:NSLocalizedString(@"Continue",nil)
												  otherButtonTitles:nil,nil];
		[errorView show];
		[errorView release];

		latestReceiptMD5 = nil;
		NSDictionary* dict = @{@"error_msg": errorString};
		[self postNotificationforStatus:kIAPPurchaseFailed withDict:dict];
	}
}

- (void)XMLRPCRequest:(XMLRPCRequest *)request didFailWithError:(NSError *)error {
	if (!_enabled) return;

	_available = true;

	LOGE(@"Communication issue (%@)", [error localizedDescription]);
	NSString *errorString = [NSString stringWithFormat:NSLocalizedString(@"Communication issue (%@)", nil), [error localizedDescription]];
	UIAlertView* errorView = [[UIAlertView alloc] initWithTitle:NSLocalizedString(@"Communication issue", nil)
														message:errorString
													   delegate:nil
											  cancelButtonTitle:NSLocalizedString(@"Continue", nil)
											  otherButtonTitles:nil,nil];
	[errorView show];
	[errorView release];
	latestReceiptMD5 = nil;
	NSDictionary* dict = @{@"error_msg": errorString};
	[self postNotificationforStatus:kIAPReceiptFailed withDict:dict];
}
#else
-(void)postNotificationforStatus:(IAPPurchaseNotificationStatus)status {
	_status = status;
	[[NSNotificationCenter defaultCenter] postNotificationName:status object:self userInfo:nil];
	LOGE(@"Not supported, triggering %@", status);
}
- (BOOL)purchaseAccount:(NSString *)phoneNumber withPassword:(NSString *)password andEmail:(NSString*)email { [self postNotificationforStatus:kIAPPurchaseFailed]; return false; }
- (BOOL)restore { [self postNotificationforStatus:kIAPRestoreFailed]; return false; }
- (BOOL)retrievePurchases { [self postNotificationforStatus:kIAPRestoreFailed]; return false; }
- (BOOL)purchaseWitID:(NSString *)productID { [self postNotificationforStatus:kIAPPurchaseFailed]; return FALSE; }
- (BOOL)isPurchasedWithID:(NSString *)productId { return FALSE; }

- (void)XMLRPCRequest:(XMLRPCRequest *)request didFailWithError:(NSError *)error { }
- (void)XMLRPCRequest:(XMLRPCRequest *)request didReceiveResponse:(XMLRPCResponse *)response { }
- (void)paymentQueue:(SKPaymentQueue *)queue updatedTransactions:(NSArray *)transactions { }
- (void)productsRequest:(SKProductsRequest *)request didReceiveResponse:(SKProductsResponse *)response { }
#endif
@end

@implementation InAppProductsXMLRPCDelegate {
	InAppProductsManager *iapm;
}

#pragma mark - XMLRPCConnectionDelegate Functions

- (void)request:(XMLRPCRequest *)request didReceiveResponse:(XMLRPCResponse *)response {
	[[[LinphoneManager instance] iapManager] XMLRPCRequest:request didReceiveResponse:response];
}

- (void)request:(XMLRPCRequest *)request didFailWithError:(NSError *)error {
	[[[LinphoneManager instance] iapManager] XMLRPCRequest:request didFailWithError:error];
}

- (BOOL)request:(XMLRPCRequest *)request canAuthenticateAgainstProtectionSpace:(NSURLProtectionSpace *)protectionSpace {
	return FALSE;
}

- (void)request:(XMLRPCRequest *)request didReceiveAuthenticationChallenge:(NSURLAuthenticationChallenge *)challenge {

}

- (void)request:(XMLRPCRequest *)request didCancelAuthenticationChallenge:(NSURLAuthenticationChallenge *)challenge {

}
@end