Share
Cosa starai creandoL'acquisto in-app è una grande funzionalità per tutti quegli sviluppatori che desiderano ottenere maggiori entrate e offrire contenuti e funzionalità extra attraverso le loro applicazioni. Ad esempio, per i giochi è possibile acquistare gemme o monete e per le app di fotografia è possibile sbloccare nuovi effetti o strumenti. E puoi fare tutto questo usando una carta di credito o un altro metodo di pagamento, senza uscire dall'app.
In questo tutorial illustrerò tutti i passaggi necessari per creare un consumabili e Non consumabile Prodotto IAP su iTunes Connect e ti mostrerò il codice necessario per acquistare entrambi gli articoli. Ho creato un progetto Xcode di esempio con un'etichetta e due pulsanti, quindi scaricalo e segui questo tutorial per capire come funziona.
Suppongo tu abbia già creato un'app per iOS in Le mie applicazioni sezione su iTunes Connect. La prima cosa che dovresti fare è creare un Sandbox Tester per testare IAP sul tuo dispositivo reale (senza simulatore, non supporta gli acquisti in-app).
accedere Utenti e ruoli, vai al Sandbox Tester scheda e fare clic sul (+) firma accanto a Tester.
Compila il modulo per aggiungere un nuovo tester sandbox. Dopo aver salvato le informazioni, torna al La mia app sezione e fai clic sull'icona della tua app per inserire i dettagli e creare prodotti IAP.
Clicca il Caratteristiche scheda e poi il (+) firma accanto a Acquisti in-app. Puoi creare un prodotto alla volta, quindi iniziamo con a consumabili uno.
UN consumabili IAP, come suggerisce il nome, è un prodotto che è possibile acquistare più volte. Lo useremo per raccogliere "monete" aggiuntive nella nostra app demo.
Clic Creare per inizializzare il tuo articolo IAP. Nella schermata successiva, puoi impostare tutte le informazioni sul tuo prodotto:
Al termine, fai clic su Salvare e riceverai questo avviso:
Il tuo primo acquisto in-app deve essere inviato con una nuova versione dell'app. Selezionalo dalla sezione Acquisti in-app dell'app e fai clic su Invia.
Ora fai clic sul pulsante Acquisti in-app nell'elenco a sinistra, subito sopra il pulsante Centro giochi pulsante e aggiungi un nuovo prodotto IAP. Questa volta, seleziona il Non consumabile opzione:
Clic Creare e ripetere i passaggi che abbiamo citato sopra. Poiché questo sarà a Non consumabile prodotto, gli utenti saranno in grado di acquistarlo solo una volta e Apple richiede la possibilità di ripristinare tali acquisti. Ciò accade nel caso in cui si disinstalli l'app e la si reinstalli nuovamente, oppure la si scarichi da un altro dispositivo con lo stesso ID Apple e sia necessario riavere i propri acquisti senza pagare per due volte. Quindi più avanti aggiungeremo un Ripristinare acquisto funzione nel nostro codice.
L'ID prodotto che abbiamo creato ora è com.iaptutorial.premium, con un livello di prezzo di $ 2,99 USD. L'abbiamo chiamato Sblocca la versione Premium.
Una volta completato il riempimento di tutti i campi, salva il tuo prodotto e torna alla pagina Acquisti in-app. Ora dovresti avere un elenco dei tuoi due prodotti, con i loro Nome, genere, ID e Stato impostato come Pronto per l'invio.
Torna alla pagina della tua app facendo clic sul App Store e Prepararsi per la presentazione pulsanti. Scorri verso il basso fino a Acquisti in-app sezione, proprio sotto Informazioni generali sull'app, e fare clic su (+) pulsante per aggiungere i tuoi prodotti IAP.
Seleziona tutti e fai clic Fatto.
Infine, fai clic Salvare nell'angolo in alto a destra dello schermo e avrai finito con la configurazione dei prodotti di acquisto in-app su iTunes Connect.
Prima di arrivare al codice, c'è ancora una cosa da fare. Vai a impostazioni > iTunes e App Store sul tuo dispositivo iOS. Se hai già effettuato l'accesso con l'ID Apple originale, toccalo e scegli Disconnessione. Quindi accedi semplicemente con le credenziali per il tester sandbox che hai creato. Dopo aver effettuato l'accesso, potresti ricevere un avviso come questo:
Ignora semplicemente il suo messaggio e tocca Annulla. Il dispositivo ti chiederà nuovamente le credenziali di accesso di Sandbox mentre tenti di effettuare un acquisto e riconoscerà il tuo account di prova in modo che non ti venga addebitato un centesimo sulla tua carta di credito per qualsiasi acquisto effettuato.
Uscita impostazioni, collega il tuo dispositivo al tuo Mac tramite il cavo USB e finalmente iniziamo a scrivere il codice!
Se hai scaricato il nostro progetto dimostrativo, vedrai che è stato scritto tutto il codice necessario per l'acquisto in-app, quindi se lo esegui otterrai qualcosa del genere:
Se vuoi testare l'app, dovresti cambiare il Identificativo del pacchetto al tuo id. In caso contrario, Xcode non ti consentirà di eseguire l'app su un dispositivo reale e l'app non riconoscerà i due prodotti IAP che hai creato.
accedere ViewController.swift e controlla il codice. Prima di tutto abbiamo aggiunto una dichiarazione di importazione per StoreKit e i delegati di cui abbiamo bisogno per monitorare le transazioni di pagamento e le richieste di prodotto.
import StoreKit class ViewController: UIViewController, SKProductsRequestDelegate, SKPaymentTransactionObserver
Quindi abbiamo dichiarato alcune visualizzazioni che saranno utili.
/ * Views * / @IBOutlet weak var coinsLabel: UILabel! @IBOutlet weak var premiumLabel: UILabel! @IBOutlet weak var consumableLabel: UILabel! @IBOutlet weak var nonConsumableLabel: UILabel!
coinsLabel e premiumLabel sarà utilizzato per mostrare i risultati degli acquisti per entrambi i prodotti. consumableLabel e nonConsumableLabel mostrerà la descrizione e il prezzo di ogni prodotto IAP, quelli che abbiamo precedentemente creato in iTunes Connect.
Ora è il momento di aggiungere alcune variabili:
/ * Variabili * / lascia COINS_PRODUCT_ID = "com.iaptutorial.coins" lascia PREMIUM_PRODUCT_ID = "com.iaptutorial.premium" var productID = "" var productsRequest = SKProductsRequest () var iapProducts = [SKProduct] () var nonConsumablePurchaseMade = UserDefaults.standard .bool (forKey: "nonConsumablePurchaseMade") var coins = UserDefaults.standard.integer (forKey: "coins")
Le prime due righe sono per richiamare i nostri ID prodotto. È importante che quelle stringhe corrispondano esattamente a quelle registrate nella sezione di acquisto in-app di iTunes Connect.
Accentsconagua
Codice prodotto è una stringa che utilizzeremo in seguito per rilevare quale prodotto sceglieremo di acquistare.productsRequest è un'istanza di SKProductsRequest, necessario per cercare prodotti IAP dalla tua app su iTC.iapProducts è una matrice semplice di SKProducts. Tieni presente che il prefisso SK indica StoreKit, il framework iOS che utilizzeremo per gestire gli acquisti.Le ultime due righe caricano due variabili di tipo booleano e Numero intero necessario per tracciare gli acquisti di monete e la versione premium, rispettivamente prodotti consumabili e non consumabili.
Il seguente codice in viewDidLoad () esegue alcune cose non appena l'app inizia:
// Controlla la stampa degli acquisti in-app ("ACQUISTO NON CONSUMABILE REALIZZATO: \ (nonConsumablePurchaseMade)") stampa ("MONETE: \ (monete)") // Imposta testo coinsLabel.text = "MONETE: \ (monete)" se nonConsumablePurchaseMade premiumLabel.text = "Versione premium ACQUISTA!" else premiumLabel.text = "Versione Premium BLOCCATA!" // Recupera i prodotti IAP disponibili fetchAvailableProducts ()Per prima cosa registriamo ogni acquisto sulla console Xcode. Quindi mostriamo la quantità totale di monete che abbiamo comprato con coinsLabel. Poiché eseguiremo l'app demo per la prima volta, verrà mostrato MONETE: 0.
Il Se la dichiarazione imposta il premiumLabelil testo in base al fatto che il prodotto non consumabile sia stato acquistato. Per iniziare, mostrerà Versione Premium BLOCCATA! poiché non abbiamo ancora effettuato l'acquisto premium.
L'ultima riga di codice chiama un metodo che vedremo in seguito, che recupera semplicemente i prodotti precedentemente archiviati in iTC.
Ora vediamo quali sono i due pulsanti di acquisto che abbiamo impostato nella nostra app dimostrativa:
// MARK: - ACQUISTA 10 COINS BUTTON @IBAction func buy10coinsButt (_ mittente: Any) purchaseMyProduct (prodotto: iapProducts [0]) // MARK: - UNLOCK PREMIUM BUTTON @IBAction func unlockPremiumButt (_ mittente: Any) purchaseMyProduct (prodotto: iapProducts [1])
Entrambi i metodi chiameranno una funzione che controllerà se il dispositivo può effettuare acquisti e, se possibile, l'app chiamerà i metodi delegati StoreKit per elaborare l'acquisto.
Come accennato prima, abbiamo bisogno di un terzo pulsante per ripristinare il nostro acquisto non consumabile. Ecco il suo codice:
// MARK: - RIPRISTINARE PULSANTE DI ACQUISTO NON CONSUMABILE @IBAction func restorePurchaseButt (_ mittente: Qualsiasi) SKPaymentQueue.default (). Add (auto) SKPaymentQueue.default (). RestoreCompletedTransactions () func paymentQueueRestoreCompletedTransactionsFinished (_ queue: SKPaymentQueue) nonConsumablePurchaseMade = true UserDefaults.standard.set (nonConsumablePurchaseMade, forKey: "nonConsumablePurchaseMade") UIAlertView (titolo: "IAP Tutorial", messaggio: "Hai ripristinato correttamente l'acquisto!", delegato: nil, cancelButtonTitle: "OK") .mostrare()
Il IBAction la funzione è allegata al Ripristinare acquisto pulsante nel storyboard e inizia a connettersi al sistema di acquisto in-app di Apple per ripristinare l'acquisto se questo è già stato fatto.
paymentQueueRestoreCompletedTransactionsFinished () è il metodo delegato dal framework StoreKit che salverà il nostro nonConsumablePurchaseMade variabile su true dopo che l'acquisto è stato ripristinato con successo.
Abbiamo finito con i pulsanti, quindi vediamo di cosa si tratta fetchAvailableProducts () la funzione fa:
// MARK: - FETCH DISPONIBILE IAP PRODUCTS func fetchAvailableProducts () // Inserisci qui i tuoi ID prodotti IAP let productIdentifiers = NSSet (oggetti: COINS_PRODUCT_ID, PREMIUM_PRODUCT_ID) productsRequest = SKProductsRequest (productIdentifiers: productIdentifiers as! Set) productsRequest.delegate = self productsRequest.start ()
Per prima cosa creiamo un'istanza di NSSet, che è fondamentalmente una serie di stringhe. Memorizzeremo i due ID prodotto che abbiamo precedentemente dichiarato.
Quindi iniziamo un SKProductsRequest in base a tali identificatori, affinché l'app visualizzi le informazioni sui prodotti IAP (descrizione e prezzo), che verranno elaborati con questo metodo di delega:
// MARK: - RICHIESTA PRODOTTI IAP prodotti funcRequest (_ richiesta: SKProductsRequest, didReceive response: SKProductsResponse) if (response.products.count> 0) iapProducts = response.products // 1st IAP Product (Consumable) ---- -------------------------------- lascia firstProduct = response.products [0] come SKProduct // Ottieni il prezzo da iTunes Connect let numberFormatter = NumberFormatter () numberFormatter.formatterBehavior = .behavior10_4 numberFormatter.numberStyle = .currency numberFormatter.locale = firstProduct.priceLocale let price1Str = numberFormatter.string (from: firstProduct.price) // Mostra la descrizione consumableLabel.text = firstProduct. localizedDescription + "\ nper solo \ (price1Str!)" // ------------------------------------ ------------ // 2 ° prodotto IAP (non consumabile) ---------------------------- - lasciare secondProd = response.products [1] come SKProduct // Ottieni il prezzo da iTunes Connect numberFormatter.locale = secondProd.priceLocale let price2Str = numberFormatter.string ( da: secondProd.price) // Mostra la descrizione nonConsumableLabel.text = secondProd.localizedDescription + "\ nper just \ (price2Str!)" // ------------------- -----------------
Nella funzione sopra descritta dobbiamo prima verificare se ci sono prodotti registrati in iTunes Connect e impostare i nostri iapProducts array di conseguenza. Quindi possiamo inizializzare i due SKProducts e stampare la loro descrizione e il prezzo sulle etichette.
Prima di arrivare al nucleo del codice di acquisto in-app, abbiamo bisogno di un paio di altre funzioni:
// MARK: - EFFETTUARE ACQUISTO DI UN PRODOTTO func canMakePurchases () -> Bool return SKPaymentQueue.canMakePayments () func purchaseMyProduct (prodotto: SKProduct) if self.canMakePurchases () let payment = SKPayment (prodotto: prodotto) SKPaymentQueue .default (). add (auto) SKPaymentQueue.default (). add (pagamento) print ("PRODOTTO DA ACQUISTARE: \ (product.productIdentifier)") productID = product.productIdentifier // Acquisti IAP dsabled sul dispositivo else UIAlertView (titolo: "IAP Tutorial", messaggio: "Gli acquisti sono disabilitati nel dispositivo!", Delegato: nil, cancelButtonTitle: "OK"). Show () Il primo controlla se il nostro dispositivo è in grado di effettuare acquisti. La seconda funzione è quella che chiamiamo dai due pulsanti. Avvia la coda di pagamento e cambia la nostra Codice prodotto variabile nel selezionato Identificatore del prodotto.
Ora siamo finalmente arrivati all'ultimo metodo delegato, quello che gestisce i risultati di pagamento:
// MARK: - CODA DI PAGAMENTO IAP func paymentQueue (_ queue: SKPaymentQueue, updatedTransactions transaction: [SKPaymentTransaction]) per transazione: AnyObject nelle transazioni se let trans = transaction as? SKPaymentTransaction switch trans.transactionState case .purchased: SKPaymentQueue.default (). FinishTransaction (transaction as! SKPaymentTransaction) // Il prodotto di consumo (10 monete) è stato acquistato -> guadagna 10 monete extra! if productID == COINS_PRODUCT_ID // Aggiungi 10 monete e salva il loro importo totale monete + = 10 UserDefaults.standard.set (monete, forKey: "monete") coinsLabel.text = "MONETE: \ (monete)" UIAlertView (titolo: "IAP Tutorial", messaggio: "Hai acquistato con successo 10 monete extra!", Delegato: nil, cancelButtonTitle: "OK"). Show () // Il prodotto non consumabile (Premium) è stato acquistato! else if productID == PREMIUM_PRODUCT_ID // Salva l'acquisto localmente (necessario solo per IAP non consumabili) nonConsumablePurchaseMade = true UserDefaults.standard.set (nonConsumablePurchaseMade, forKey: "nonConsumablePurchaseMade") premiumLabel.text = "Versione premium ACQUISTA!" UIAlertView (titolo: "IAP Tutorial", messaggio: "Hai sbloccato con successo la versione Premium!", Delegato: nil, cancelButtonTitle: "OK"). Show () break case. Fallito: SKPaymentQueue.default (). FinishTransaction (transaction as! SKPaymentTransaction) break case .restored: SKPaymentQueue.default (). finishTransaction (transaction as! SKPaymentTransaction) break default: break
Questa funzione ha a interruttore dichiarazione che controlla ogni stato del pagamento. Il primo Astuccio viene chiamato se l'acquisto è stato effettuato correttamente e completa la sua transazione.
All'interno di questo blocco dobbiamo verificare quale ID prodotto abbiamo selezionato ed eseguire le azioni necessarie per aggiornare la nostra app, quindi se l'utente ha acquistato 10 monete extra, aggiungeremo 10 al nostro monete variabile, salva il suo valore con UserDefaults, mostra la nuova quantità di monete che abbiamo guadagnato e fai un avviso a riguardo.
Tieni presente che puoi effettuare questo acquisto più volte senza limiti poiché si tratta di un IAP consumabile e non è necessario ripristinare la funzione di acquisto.
Allo stesso modo, se acquistassimo il prodotto premium non consumabile, l'app imposta il nostro nonConsumablePurchaseMade variabile a vero, lo salva, cambia il testo del premiumLabel, e attiva un avviso per informarti che l'acquisto è andato a buon fine.
Gli altri due casi gestire i risultati del pagamento per fallimento e ripristino. L'app genera avvisi personalizzati autonomamente se la transazione non riesce per qualche motivo o se hai ripristinato un acquisto non di consumo.
Questo è tutto! Ora assicurati di aver effettuato l'accesso con le tue credenziali Sandbox Tester ed esegui l'app per testarlo. La prima volta, riceverai un avviso come questo:
Scegliere Usa l'ID Apple esistente e inserisci nuovamente il nome utente e la password di Sandbox Tester per accedere. Ciò accade perché l'app può riconoscere solo un utente reale dal iTunes e App Store impostazioni, non una Sandbox.
Una volta effettuato l'accesso, potrai eseguire gli acquisti di entrambi i prodotti.
Se lavori con iOS e vuoi approfondire lo sviluppo della lingua e delle app di Swift, controlla alcuni dei miei modelli di app iOS su CodeCanyon.
Ci sono anche centinaia di altri modelli di app iOS sul mercato Envato, pronti per essere ripresi e sicuri di velocizzare il tuo flusso di lavoro. Vai a dare un'occhiata! Potresti solo risparmiare ore di lavoro sulla tua prossima app.
In questo tutorial, abbiamo coperto tutti i passaggi necessari per creare prodotti di acquisto in-app su iTunes Connect e come scrivere il codice per abilitarli nella tua app. Spero che tu sia in grado di utilizzare questa conoscenza nella tua prossima app iOS!
Grazie per la lettura, e ci vediamo la prossima volta! Consulta i nostri altri corsi ed esercitazioni sullo sviluppo di app per iOS con Swift.
