web-dev-qa-db-de.com

Wie fügen Sie einer iOS-Anwendung einen In-App-Kauf hinzu?

Wie fügen Sie einer iOS-App einen In-App-Kauf hinzu? Was sind alle Details und gibt es Beispielcode? 

Dies ist eine gute Möglichkeit, um In-App-Käufe zu iOS-Apps hinzuzufügen

246
Jojodmo

Der beste Weg, um einen In-App-Kauf für iOS 7 - iOS 12 in Xcode 5+ zum Laufen zu bringen, ist der folgende:

Schnelle Benutzer

Schnelle Benutzer können auschecken My Swift Beantworten Sie diese Frage .
Oder lesen Sie Yedidya Reiss 'Antwort , das diesen Objective-C-Code in Swift übersetzt.

App Store Connect

  1. Gehen Sie zu appstoreconnect.Apple.com und melden Sie sich an
  2. Klicken Sie auf My Apps Und dann auf die App, der Sie den Kauf hinzufügen möchten
  3. Klicken Sie auf die Überschrift Features und wählen Sie dann links In-App Purchases
  4. Klicken Sie in der Mitte auf das Symbol +
  5. In diesem Tutorial fügen wir einen In-App-Kauf hinzu, um Anzeigen zu entfernen. Wählen Sie also non-consumable. Wenn Sie dem Benutzer einen physischen Artikel senden oder ihm etwas geben möchten, das er mehrmals kaufen kann, wählen Sie consumable.
  6. Geben Sie als Referenznamen an, was Sie möchten (stellen Sie jedoch sicher, dass Sie wissen, was es ist).
  7. Für die Produkt-ID put tld.websitename.appname.referencename Funktioniert dies am besten. Sie können also zum Beispiel com.jojodmo.blix.removeads Verwenden.
  8. Wählen Sie cleared for sale Und dann Preisstufe 1 (99 ¢). Tier 2 wäre $ 1,99 und Tier 3 wäre $ 2,99. Die vollständige Liste ist verfügbar, wenn Sie auf view pricing matrix Klicken. Ich empfehle, Tier 1 zu verwenden, da dies normalerweise der Höchstbetrag ist, den jemals jemand für das Entfernen von Anzeigen bezahlt.
  9. Klicken Sie auf die blaue Schaltfläche add language Und geben Sie die Informationen ein. Dies wird ALLEN Kunden gezeigt, also platzieren Sie nichts, was Sie nicht wollen, dass sie sehen
  10. Für hosting content with Apple Wählen Sie no
  11. Sie können die Bewertungsnotizen leer lassen FÜR JETZT.
  12. Überspringen Sie den screenshot for review FOR NOW, auf alles, was wir überspringen, kommen wir zurück.
  13. Klicken Sie auf "Speichern"

Es kann einige Stunden dauern, bis sich Ihre Produkt-ID in App Store Connect Registriert hat. Seien Sie also geduldig.

Einrichten Ihres Projekts

Nachdem Sie Ihre In-App-Kaufinformationen in App Store Connect eingerichtet haben, wechseln Sie in Ihr Xcode-Projekt und rufen Sie den Anwendungsmanager auf (blaues seitenähnliches Symbol oben auf der Seite, auf der sich Ihre Methoden und Header-Dateien befinden) Deine App unter Ziele (sollte die erste sein) dann gehe zu Allgemein. Unten solltest du sehen, dass linked frameworks and libraries Auf das kleine Plus-Symbol klickt und das Framework StoreKit.framework Hinzufügt. Wenn du dies nicht tust, wird der In-App-Kauf [~ # ~ ] nicht [~ # ~] arbeiten!

Wenn Sie Objective-C als Sprache für Ihre App verwenden, sollten Sie diese fünf Schritte überspringen. Andernfalls können Sie, wenn Sie Swift verwenden, My Swift Beantworten Sie diese Frage hier oder, wenn Sie Objective-C für die In- App-Kaufcode, aber mit Swift in Ihrer App können Sie Folgendes tun:

  1. Erstellen Sie eine neue .h (Header) -Datei, indem Sie zu File> New> File... Wechseln (Command ⌘ + N). Diese Datei wird im Rest des Tutorials als "Ihre .h - Datei" bezeichnet

  2. Klicken Sie auf Create Bridging Header , wenn Sie dazu aufgefordert werden. Dies wird unsere Bridging-Header-Datei sein. Wenn Sie nicht dazu aufgefordert werden, fahren Sie mit Schritt 3 fort. Wenn Sie werden dazu aufgefordert werden, überspringen Sie Schritt 3 und fahren Sie direkt mit Schritt 4 fort.

  3. Erstellen Sie eine weitere .h - Datei mit dem Namen Bridge.h Im Hauptprojektordner. Wechseln Sie dann zum Anwendungsmanager (blaues seitenähnliches Symbol) und wählen Sie Ihre App im Abschnitt Targets aus , und klicken Sie auf Build Settings. Suchen Sie die Option Swift Compiler - Codegenerierung und setzen Sie die Option Objective-C Bridging Header auf Bridge.h

  4. Fügen Sie in Ihrer Bridging-Header-Datei die Zeile #import "MyObjectiveCHeaderFile.h" Hinzu, wobei MyObjectiveCHeaderFile der Name der Header-Datei ist, die Sie in Schritt 1 erstellt haben. Wenn Sie beispielsweise Ihre Header-Datei InAppPurchase.h benannt haben, fügen Sie der Bridge-Header-Datei die Zeile #import "InAppPurchase.h" Hinzu.

  5. Erstellen Sie eine neue Objective-C-Methodendatei (.m), Indem Sie zu File> New> File... Wechseln (Command ⌘ + N). Nennen Sie es genauso wie die in Schritt 1 erstellte Header-Datei. Wenn Sie die Datei beispielsweise in Schritt 1 InAppPurchase.h aufgerufen haben, würden Sie diese neue Datei InAppPurchase aufrufen. m. Diese Datei wird im Rest des Tutorials als "Ihre .m - Datei" bezeichnet.

Codierung

Jetzt werden wir uns mit der eigentlichen Codierung befassen. Fügen Sie den folgenden Code in Ihre .h - Datei ein:

BOOL areAdsRemoved;

- (IBAction)restore;
- (IBAction)tapsRemoveAds;

Als Nächstes müssen Sie das StoreKit - Framework in Ihre .m - Datei importieren und nach Ihrer @interface - Deklaration SKProductsRequestDelegate und SKPaymentTransactionObserver hinzufügen :

#import <StoreKit/StoreKit.h>

//put the name of your view controller in place of MyViewController
@interface MyViewController() <SKProductsRequestDelegate, SKPaymentTransactionObserver>

@end

@implementation MyViewController //the name of your view controller (same as above)
  //the code below will be added here
@end

wenn Sie nun Folgendes in Ihre .m - Datei einfügen, wird dieser Teil kompliziert. Ich empfehle Ihnen daher, die Kommentare im Code zu lesen:

//If you have more than one in-app purchase, you can define both of
//of them here. So, for example, you could define both kRemoveAdsProductIdentifier
//and kBuyCurrencyProductIdentifier with their respective product ids
//
//for this example, we will only use one product

#define kRemoveAdsProductIdentifier @"put your product id (the one that we just made in App Store Connect) in here"

- (IBAction)tapsRemoveAds{
    NSLog(@"User requests to remove ads");

    if([SKPaymentQueue canMakePayments]){
        NSLog(@"User can make payments");

        //If you have more than one in-app purchase, and would like
        //to have the user purchase a different product, simply define 
        //another function and replace kRemoveAdsProductIdentifier with 
        //the identifier for the other product

        SKProductsRequest *productsRequest = [[SKProductsRequest alloc] initWithProductIdentifiers:[NSSet setWithObject:kRemoveAdsProductIdentifier]];
        productsRequest.delegate = self;
        [productsRequest start];

    }
    else{
        NSLog(@"User cannot make payments due to parental controls");
        //this is called the user cannot make payments, most likely due to parental controls
    }
}

- (void)productsRequest:(SKProductsRequest *)request didReceiveResponse:(SKProductsResponse *)response{
    SKProduct *validProduct = nil;
    int count = [response.products count];
    if(count > 0){
        validProduct = [response.products objectAtIndex:0];
        NSLog(@"Products Available!");
        [self purchase:validProduct];
    }
    else if(!validProduct){
        NSLog(@"No products available");
        //this is called if your product id is not valid, this shouldn't be called unless that happens.
    }
}

- (void)purchase:(SKProduct *)product{
    SKPayment *payment = [SKPayment paymentWithProduct:product];

    [[SKPaymentQueue defaultQueue] addTransactionObserver:self];
    [[SKPaymentQueue defaultQueue] addPayment:payment];
}

- (IBAction) restore{
    //this is called when the user restores purchases, you should hook this up to a button
    [[SKPaymentQueue defaultQueue] addTransactionObserver:self];
    [[SKPaymentQueue defaultQueue] restoreCompletedTransactions];
}

- (void) paymentQueueRestoreCompletedTransactionsFinished:(SKPaymentQueue *)queue
{
    NSLog(@"received restored transactions: %i", queue.transactions.count);
    for(SKPaymentTransaction *transaction in queue.transactions){
        if(transaction.transactionState == SKPaymentTransactionStateRestored){
            //called when the user successfully restores a purchase
            NSLog(@"Transaction state -> Restored");

            //if you have more than one in-app purchase product,
            //you restore the correct product for the identifier.
            //For example, you could use
            //if(productID == kRemoveAdsProductIdentifier)
            //to get the product identifier for the
            //restored purchases, you can use
            //
            //NSString *productID = transaction.payment.productIdentifier;
            [self doRemoveAds];
            [[SKPaymentQueue defaultQueue] finishTransaction:transaction];
            break;
        }
    }   
}

- (void)paymentQueue:(SKPaymentQueue *)queue updatedTransactions:(NSArray *)transactions{
    for(SKPaymentTransaction *transaction in transactions){
        //if you have multiple in app purchases in your app,
        //you can get the product identifier of this transaction
        //by using transaction.payment.productIdentifier
        //
        //then, check the identifier against the product IDs
        //that you have defined to check which product the user
        //just purchased            

        switch(transaction.transactionState){
            case SKPaymentTransactionStatePurchasing: NSLog(@"Transaction state -> Purchasing");
                //called when the user is in the process of purchasing, do not add any of your own code here.
                break;
            case SKPaymentTransactionStatePurchased:
            //this is called when the user has successfully purchased the package (Cha-Ching!)
                [self doRemoveAds]; //you can add your code for what you want to happen when the user buys the purchase here, for this tutorial we use removing ads
                [[SKPaymentQueue defaultQueue] finishTransaction:transaction];
                NSLog(@"Transaction state -> Purchased");
                break;
            case SKPaymentTransactionStateRestored:
                NSLog(@"Transaction state -> Restored");
                //add the same code as you did from SKPaymentTransactionStatePurchased here
                [[SKPaymentQueue defaultQueue] finishTransaction:transaction];
                break;
            case SKPaymentTransactionStateFailed:
                //called when the transaction does not finish
                if(transaction.error.code == SKErrorPaymentCancelled){
                    NSLog(@"Transaction state -> Cancelled");
                    //the user cancelled the payment ;(
                }
                [[SKPaymentQueue defaultQueue] finishTransaction:transaction];
                break;
        }
    }
}

Jetzt möchten Sie Ihren Code hinzufügen, um zu erfahren, was passiert, wenn der Benutzer die Transaktion abschließt. In diesem Tutorial verwenden wir das Entfernen von Hinzufügungen. Sie müssen Ihren eigenen Code hinzufügen, um zu erfahren, was passiert, wenn die Banneransicht geladen wird.

- (void)doRemoveAds{
    ADBannerView *banner;
    [banner setAlpha:0];
    areAdsRemoved = YES;
    removeAdsButton.hidden = YES;
    removeAdsButton.enabled = NO;
    [[NSUserDefaults standardUserDefaults] setBool:areAdsRemoved forKey:@"areAdsRemoved"];
    //use NSUserDefaults so that you can load whether or not they bought it
    //it would be better to use KeyChain access, or something more secure
    //to store the user data, because NSUserDefaults can be changed.
    //You're average downloader won't be able to change it very easily, but
    //it's still best to use something more secure than NSUserDefaults.
    //For the purpose of this tutorial, though, we're going to use NSUserDefaults
    [[NSUserDefaults standardUserDefaults] synchronize];
}

Wenn Ihre Anwendung keine Anzeigen enthält, können Sie jede andere Funktion verwenden. Zum Beispiel könnten wir die Farbe des Hintergrunds blau machen. Dazu möchten wir verwenden:

- (void)doRemoveAds{
    [self.view setBackgroundColor:[UIColor blueColor]];
    areAdsRemoved = YES
    //set the bool for whether or not they purchased it to YES, you could use your own boolean here, but you would have to declare it in your .h file

    [[NSUserDefaults standardUserDefaults] setBool:areAdsRemoved forKey:@"areAdsRemoved"];
    //use NSUserDefaults so that you can load wether or not they bought it
    [[NSUserDefaults standardUserDefaults] synchronize];
}

Nun möchten Sie irgendwo in Ihrer viewDidLoad -Methode den folgenden Code hinzufügen:

areAdsRemoved = [[NSUserDefaults standardUserDefaults] boolForKey:@"areAdsRemoved"];
[[NSUserDefaults standardUserDefaults] synchronize];
//this will load wether or not they bought the in-app purchase

if(areAdsRemoved){
    [self.view setBackgroundColor:[UIColor blueColor]];
    //if they did buy it, set the background to blue, if your using the code above to set the background to blue, if your removing ads, your going to have to make your own code here
}

Nachdem Sie den gesamten Code hinzugefügt haben, gehen Sie in Ihre Datei .xib Oder storyboard und fügen Sie zwei Schaltflächen hinzu, von denen eine "Kauf" und die andere "Wiederherstellen" sagt. Schließen Sie die tapsRemoveAdsIBAction an die Kaufschaltfläche an, die Sie gerade erstellt haben, und die restoreIBAction an die Wiederherstellungsschaltfläche. Die Aktion restore prüft, ob der Benutzer den In-App-Kauf bereits gekauft hat, und gibt ihm den In-App-Kauf kostenlos, wenn er ihn noch nicht hat.

Einreichen zur Überprüfung

Gehen Sie als Nächstes zu App Store Connect und klicken Sie auf Users and Access. Klicken Sie dann auf die Überschrift Sandbox Testers Und dann auf das Symbol + Links davon sagt Testers. Sie können nur zufällige Dinge für den Vor- und Nachnamen eingeben, und die E-Mail muss nicht echt sein - Sie müssen sich nur daran erinnern können. Geben Sie ein Passwort ein (das Sie sich merken müssen) und füllen Sie den Rest der Informationen aus. Ich würde empfehlen, dass Sie das Date of Birth Zu einem Datum machen, das den Benutzer 18 oder älter machen würde. App Store Territory [~ # ~] muss [~ # ~] im richtigen Land sein. Melden Sie sich anschließend von Ihrem vorhandenen iTunes-Konto ab (Sie können sich nach diesem Tutorial wieder anmelden).

Führen Sie nun Ihre Anwendung auf Ihrem iOS-Gerät aus. Wenn Sie versuchen, sie auf dem Simulator auszuführen, wird der Kauf always fehlschlagen. Sie MÜSSEN ausführen es auf Ihrem iOS-Gerät. Sobald die App ausgeführt wird, tippen Sie auf die Schaltfläche "Kaufen". Wenn Sie aufgefordert werden, sich bei Ihrem iTunes-Konto anzumelden, melden Sie sich als der Testbenutzer an, den wir gerade erstellt haben. Wenn Sie dann aufgefordert werden, den Kauf von 99 ¢ zu bestätigen, oder was auch immer Sie für die Preisstufe festgelegt haben, SCHNAPPSCHUSS DARSTELLEN , verwenden Sie dies für Ihre screenshot for review Im App Store Connect. Jetzt stornieren Sie die Zahlung.

Gehen Sie jetzt zu App Store Connect und dann zu My Apps> the app you have the In-app purchase on> In-App Purchases. Klicken Sie dann auf Ihren In-App-Kauf und klicken Sie unter den In-App-Kaufdetails auf Bearbeiten. Sobald Sie dies getan haben, importieren Sie das Foto, das Sie gerade auf Ihrem iPhone aufgenommen haben, in Ihren Computer und laden Sie es als Screenshot zur Überprüfung hoch. Tragen Sie dann in die Überprüfungsnotizen Ihren TEST USER ein E-Mail und Passwort. Dies wird Apple im Überprüfungsprozess helfen.

Nachdem Sie dies getan haben, kehren Sie zu der Anwendung auf Ihrem iOS-Gerät zurück, die noch als Testbenutzerkonto angemeldet ist, und klicken Sie auf die Schaltfläche "Kaufen". Bestätige diesmal die Zahlung Keine Sorge, dein Konto wird NICHT belastet. Testbenutzerkonten erhalten alle In-App-Käufe kostenlos. Nachdem du die Zahlung bestätigt hast, Stellen Sie sicher, dass das, was passiert, wenn der Benutzer Ihr Produkt kauft, tatsächlich passiert. Wenn dies nicht der Fall ist, liegt ein Fehler bei Ihrer Methode doRemoveAds vor. Auch hier empfehle ich, den Hintergrund zum Testen des In-App-Kaufs in Blau zu ändern. Dies sollte jedoch nicht Ihr tatsächlicher In-App-Kauf sein. Wenn alles funktioniert und Sie können loslegen! Stellen Sie einfach sicher, dass Sie den In-App-Kauf in Ihre neue Binärdatei aufnehmen, wenn Sie sie in App Store Connect hochladen!


Hier sind einige häufige Fehler:

Gespeichert: No Products Available

Dies könnte drei Dinge bedeuten:

  • Sie haben nicht die richtige In-App-Kauf-ID in Ihren Code eingegeben (für die ID kRemoveAdsProductIdentifier im obigen Code)
  • Sie haben Ihren In-App-Kauf zum Verkauf am App Store Connect nicht abgeschlossen
  • Sie haben nicht darauf gewartet, dass die In-App-Kauf-ID in App Store Connect registriert wird. Warten Sie ein paar Stunden nach dem Erstellen der ID, und Ihr Problem sollte behoben sein.
  • Sie haben Ihre Vertrags-, Steuer- und Bankdaten nicht vollständig ausgefüllt.

Wenn es beim ersten Mal nicht funktioniert, seien Sie nicht frustriert! Gib nicht auf! Es dauerte ungefähr 5 Stunden, bis ich das zum Laufen brachte, und ungefähr 10 Stunden, bis ich nach dem richtigen Code suchte! Wenn Sie den obigen Code genau verwenden, sollte es gut funktionieren. Fühlen Sie sich frei zu kommentieren, wenn Sie Fragen haben überhaupt.

Ich hoffe, dies hilft all jenen, die hoffen, ihrer iOS-Anwendung einen In-App-Kauf hinzuzufügen. Prost!

543
Jojodmo

Übersetzen Sie einfach Jojodmo-Code in Swift:

class InAppPurchaseManager: NSObject , SKProductsRequestDelegate, SKPaymentTransactionObserver{





//If you have more than one in-app purchase, you can define both of
//of them here. So, for example, you could define both kRemoveAdsProductIdentifier
//and kBuyCurrencyProductIdentifier with their respective product ids
//
//for this example, we will only use one product

let kRemoveAdsProductIdentifier = "put your product id (the one that we just made in iTunesConnect) in here"

@IBAction func tapsRemoveAds() {

    NSLog("User requests to remove ads")

    if SKPaymentQueue.canMakePayments() {
        NSLog("User can make payments")

        //If you have more than one in-app purchase, and would like
        //to have the user purchase a different product, simply define
        //another function and replace kRemoveAdsProductIdentifier with
        //the identifier for the other product
        let set : Set<String> = [kRemoveAdsProductIdentifier]
        let productsRequest = SKProductsRequest(productIdentifiers: set)
        productsRequest.delegate = self
        productsRequest.start()

    }
    else {
        NSLog("User cannot make payments due to parental controls")
        //this is called the user cannot make payments, most likely due to parental controls
    }
}


func purchase(product : SKProduct) {

    let payment = SKPayment(product: product)
    SKPaymentQueue.defaultQueue().addTransactionObserver(self)
    SKPaymentQueue.defaultQueue().addPayment(payment)
}

func restore() {
    //this is called when the user restores purchases, you should hook this up to a button
    SKPaymentQueue.defaultQueue().addTransactionObserver(self)
    SKPaymentQueue.defaultQueue().restoreCompletedTransactions()
}


func doRemoveAds() {
    //TODO: implement
}

/////////////////////////////////////////////////
//////////////// store delegate /////////////////
/////////////////////////////////////////////////
// MARK: - store delegate -


func productsRequest(request: SKProductsRequest, didReceiveResponse response: SKProductsResponse) {

    if let validProduct = response.products.first {
        NSLog("Products Available!")
        self.purchase(validProduct)
    }
    else {
        NSLog("No products available")
        //this is called if your product id is not valid, this shouldn't be called unless that happens.
    }
}

func paymentQueueRestoreCompletedTransactionsFinished(queue: SKPaymentQueue) {


    NSLog("received restored transactions: \(queue.transactions.count)")
    for transaction in queue.transactions {
        if transaction.transactionState == .Restored {
            //called when the user successfully restores a purchase
            NSLog("Transaction state -> Restored")

            //if you have more than one in-app purchase product,
            //you restore the correct product for the identifier.
            //For example, you could use
            //if(productID == kRemoveAdsProductIdentifier)
            //to get the product identifier for the
            //restored purchases, you can use
            //
            //NSString *productID = transaction.payment.productIdentifier;
            self.doRemoveAds()
            SKPaymentQueue.defaultQueue().finishTransaction(transaction)
            break;
        }
    }
}


func paymentQueue(queue: SKPaymentQueue, updatedTransactions transactions: [SKPaymentTransaction]) {

    for transaction in transactions {
        switch transaction.transactionState {
        case .Purchasing: NSLog("Transaction state -> Purchasing")
            //called when the user is in the process of purchasing, do not add any of your own code here.
        case .Purchased:
            //this is called when the user has successfully purchased the package (Cha-Ching!)
            self.doRemoveAds() //you can add your code for what you want to happen when the user buys the purchase here, for this tutorial we use removing ads
            SKPaymentQueue.defaultQueue().finishTransaction(transaction)
            NSLog("Transaction state -> Purchased")
        case .Restored:
            NSLog("Transaction state -> Restored")
            //add the same code as you did from SKPaymentTransactionStatePurchased here
            SKPaymentQueue.defaultQueue().finishTransaction(transaction)
        case .Failed:
            //called when the transaction does not finish
            if transaction.error?.code == SKErrorPaymentCancelled {
                NSLog("Transaction state -> Cancelled")
                //the user cancelled the payment ;(
            }
            SKPaymentQueue.defaultQueue().finishTransaction(transaction)
        case .Deferred:
            // The transaction is in the queue, but its final status is pending external action.
            NSLog("Transaction state -> Deferred")

        }


    }
}
} 
12
Yedidya Reiss

RMStore ist eine einfache iOS-Bibliothek für In-App-Käufe. Es umschließt die StoreKit-API und bietet praktische Blöcke für asynchrone Anforderungen. Der Kauf eines Produkts ist so einfach wie das Aufrufen einer einzelnen Methode. 

Für fortgeschrittene Benutzer bietet diese Bibliothek auch eine Bestätigung der Empfangsbestätigung, Herunterladen von Inhalten und eine dauerhafte Transaktion. 

4

Schnelle Antwort

Dies soll meine Objective-C-Antwort für Swift Benutzer ergänzen, damit die Objective-C-Antwort nicht zu groß wird.

Konfiguration

Richten Sie zuerst den In-App-Kauf auf appstoreconnect.Apple.com ein. Befolgen Sie den Anfang von meine Objective-C-Antwort (Schritte 1-13 unter der Überschrift App Store Connect ), um Anweisungen zu erhalten auf das zu tun.

Es kann einige Stunden dauern, bis sich Ihre Produkt-ID im App Store Connect registriert hat. Seien Sie also geduldig.

Nachdem Sie Ihre In-App-Kaufinformationen in App Store Connect eingerichtet haben, müssen Sie der App das Apple-Framework für In-App-Käufe StoreKit hinzufügen.

Rufen Sie Ihr Xcode-Projekt auf und rufen Sie den Anwendungsmanager auf (blaues seitenähnliches Symbol oben in der linken Leiste, in der sich die Dateien Ihrer Anwendung befinden). Klicken Sie links unter "Ziele" auf Ihre App (dies sollte die erste Option sein) und gehen Sie dann oben zu "Funktionen". Auf der Liste sollte die Option "In-App-Kauf" angezeigt werden. Wenn Sie diese Funktion aktivieren, fügt Xcode Ihrem Projekt StoreKit hinzu.

Codierung

Jetzt fangen wir an zu programmieren!

Erstellen Sie zunächst eine neue Swift Datei, die alle Ihre In-App-Käufe verwaltet. Ich werde es IAPManager.Swift nennen.

In dieser Datei erstellen wir eine neue Klasse mit dem Namen IAPManager, die SKProductsRequestDelegate und SKPaymentTransactionObserver ist. Stellen Sie oben sicher, dass Sie Foundation und StoreKit importieren.

import Foundation
import StoreKit

public class IAPManager: NSObject, SKProductsRequestDelegate,
                         SKPaymentTransactionObserver {
}

Als Nächstes fügen wir eine Variable hinzu, um die ID für unseren In-App-Kauf zu definieren (Sie könnten auch eine enum verwenden, die einfacher zu pflegen wäre, wenn Sie über mehrere IAPs verfügen).

// This should the ID of the in-app-purchase you made on AppStore Connect.
// if you have multiple IAPs, you'll need to store their identifiers in
// other variables, too (or, preferably in an enum).
let removeAdsID = "com.skiplit.removeAds"

Fügen wir als nächstes einen Initialisierer für unsere Klasse hinzu:

// This is the initializer for your IAPManager class
//
// A better, and more scaleable way of doing this
// is to also accept a callback in the initializer, and call
// that callback in places like the paymentQueue function, and
// in all functions in this class, in place of calls to functions
// in RemoveAdsManager (you'll see those calls in the code below).

let productID: String
init(productID: String){
    self.productID = productID
}

Nun werden wir die erforderlichen Funktionen hinzufügen, damit SKProductsRequestDelegate und SKPaymentTransactionObserver funktionieren:

Wir werden die Klasse RemoveAdsManager später hinzufügen

// This is called when a SKProductsRequest receives a response
public func productsRequest(_ request: SKProductsRequest, didReceive response: SKProductsResponse){
    // Let's try to get the first product from the response
    // to the request
    if let product = response.products.first{
        // We were able to get the product! Make a new payment
        // using this product
        let payment = SKPayment(product: product)

        // add the new payment to the queue
        SKPaymentQueue.default().add(self)
        SKPaymentQueue.default().add(payment)
    }
    else{
        // Something went wrong! It is likely that either
        // the user doesn't have internet connection, or
        // your product ID is wrong!
        //
        // Tell the user in requestFailed() by sending an alert,
        // or something of the sort

        RemoveAdsManager.removeAdsFailure()
    }
}

// This is called when the user restores their IAP sucessfully
private func paymentQueueRestoreCompletedTransactionsFinished(_ queue: SKPaymentQueue){
    // For every transaction in the transaction queue...
    for transaction in queue.transactions{
        // If that transaction was restored
        if transaction.transactionState == .restored{
            // get the producted ID from the transaction
            let productID = transaction.payment.productIdentifier

            // In this case, we have only one IAP, so we don't need to check
            // what IAP it is. However, this is useful if you have multiple IAPs!
            // You'll need to figure out which one was restored
            if(productID.lowercased() == IAPManager.removeAdsID.lowercased()){
                // Restore the user's purchases
                RemoveAdsManager.restoreRemoveAdsSuccess()
            }

            // finish the payment
            SKPaymentQueue.default().finishTransaction(transaction)
        }
    }
}

// This is called when the state of the IAP changes -- from purchasing to purchased, for example.
// This is where the magic happens :)
public func paymentQueue(_ queue: SKPaymentQueue, updatedTransactions transactions: [SKPaymentTransaction]){
    for transaction in transactions{
        // get the producted ID from the transaction
        let productID = transaction.payment.productIdentifier

        // In this case, we have only one IAP, so we don't need to check
        // what IAP it is.
        // However, if you have multiple IAPs, you'll need to use productID
        // to check what functions you should run here!

        switch transaction.transactionState{
        case .purchasing:
            // if the user is currently purchasing the IAP,
            // we don't need to do anything.
            //
            // You could use this to show the user
            // an activity indicator, or something like that
            break
        case .purchased:
            // the user successfully purchased the IAP!
            RemoveAdsManager.removeAdsSuccess()
            SKPaymentQueue.default().finishTransaction(transaction)
        case .restored:
                // the user restored their IAP!
                IAPTestingHandler.restoreRemoveAdsSuccess()
                SKPaymentQueue.default().finishTransaction(transaction)
        case .failed:
                // The transaction failed!
                RemoveAdsManager.removeAdsFailure()
                // finish the transaction
                SKPaymentQueue.default().finishTransaction(transaction)
        case .deferred:
                // This happens when the IAP needs an external action
                // in order to proceeded, like Ask to Buy
                RemoveAdsManager.removeAdsDeferred()
                break
        }
    }
}

Fügen wir nun einige Funktionen hinzu, die zum Starten eines Kaufs oder zum Wiederherstellen von Käufen verwendet werden können:

// Call this when you want to begin a purchase
// for the productID you gave to the initializer
public func beginPurchase(){
    // If the user can make payments
    if SKPaymentQueue.canMakePayments(){
        // Create a new request
        let request = SKProductsRequest(productIdentifiers: [productID])
        // Set the request delegate to self, so we receive a response
        request.delegate = self
        // start the request
        request.start()
    }
    else{
        // Otherwise, tell the user that
        // they are not authorized to make payments,
        // due to parental controls, etc
    }
}

// Call this when you want to restore all purchases
// regardless of the productID you gave to the initializer
public func beginRestorePurchases(){
    // restore purchases, and give responses to self
    SKPaymentQueue.default().add(self)
    SKPaymentQueue.default().restoreCompletedTransactions()
}

Als Nächstes fügen wir eine neue Dienstprogrammklasse hinzu, um unsere IAPs zu verwalten. All dieser Code könnte in einer Klasse enthalten sein, aber wenn er mehrfach vorhanden ist, wird er ein wenig übersichtlicher. Ich werde eine neue Klasse namens RemoveAdsManager erstellen und darin einige Funktionen einfügen

public class RemoveAdsManager{

    class func removeAds()
    class func restoreRemoveAds()

    class func areAdsRemoved() -> Bool

    class func removeAdsSuccess()
    class func restoreRemoveAdsSuccess()
    class func removeAdsDeferred()
    class func removeAdsFailure()
}

Die ersten drei Funktionen, removeAds, restoreRemoveAds und areAdsRemoved, sind Funktionen, die Sie aufrufen, um bestimmte Aktionen auszuführen. Die letzten vier werden von IAPManager aufgerufen.

Fügen wir den ersten beiden Funktionen removeAds und restoreRemoveAds Code hinzu:

// Call this when the user wants
// to remove ads, like when they
// press a "remove ads" button
class func removeAds(){
    // Before starting the purchase, you could tell the
    // user that their purchase is happening, maybe with
    // an activity indicator

    let iap = IAPManager(productID: IAPManager.removeAdsID)
    iap.beginPurchase()
}

// Call this when the user wants
// to restore their IAP purchases,
// like when they press a "restore
// purchases" button.
class func restoreRemoveAds(){
    // Before starting the purchase, you could tell the
    // user that the restore action is happening, maybe with
    // an activity indicator

    let iap = IAPManager(productID: IAPManager.removeAdsID)
    iap.beginRestorePurchases()
}

Zuletzt fügen wir den letzten fünf Funktionen Code hinzu.

// Call this to check whether or not
// ads are removed. You can use the
// result of this to hide or show
// ads
class func areAdsRemoved() -> Bool{
    // This is the code that is run to check
    // if the user has the IAP.

    return UserDefaults.standard.bool(forKey: "RemoveAdsPurchased")
}

// This will be called by IAPManager
// when the user sucessfully purchases
// the IAP
class func removeAdsSuccess(){
    // This is the code that is run to actually
    // give the IAP to the user!
    //
    // I'm using UserDefaults in this example,
    // but you may want to use Keychain,
    // or some other method, as UserDefaults
    // can be modified by users using their
    // computer, if they know how to, more
    // easily than Keychain

    UserDefaults.standard.set(true, forKey: "RemoveAdsPurchased")
    UserDefaults.standard.synchronize()
}

// This will be called by IAPManager
// when the user sucessfully restores
//  their purchases
class func restoreRemoveAdsSuccess(){
    // Give the user their IAP back! Likely all you'll need to
    // do is call the same function you call when a user
    // sucessfully completes their purchase. In this case, removeAdsSuccess()

    removeAdsSuccess()
}

// This will be called by IAPManager
// when the IAP failed
class func removeAdsFailure(){
    // Send the user a message explaining that the IAP
    // failed for some reason, and to try again later
}

// This will be called by IAPManager
// when the IAP gets deferred.
class func removeAdsDeferred(){
    // Send the user a message explaining that the IAP
    // was deferred, and pending an external action, like
    // Ask to Buy.
}

Wenn wir alles zusammenfassen, erhalten wir so etwas:

import Foundation
import StoreKit

public class RemoveAdsManager{

    // Call this when the user wants
    // to remove ads, like when they
    // press a "remove ads" button
    class func removeAds(){
        // Before starting the purchase, you could tell the
        // user that their purchase is happening, maybe with
        // an activity indicator

        let iap = IAPManager(productID: IAPManager.removeAdsID)
        iap.beginPurchase()
    }

    // Call this when the user wants
    // to restore their IAP purchases,
    // like when they press a "restore
    // purchases" button.
    class func restoreRemoveAds(){
        // Before starting the purchase, you could tell the
        // user that the restore action is happening, maybe with
        // an activity indicator

        let iap = IAPManager(productID: IAPManager.removeAdsID)
        iap.beginRestorePurchases()
    }

    // Call this to check whether or not
    // ads are removed. You can use the
    // result of this to hide or show
    // ads
    class func areAdsRemoved() -> Bool{
        // This is the code that is run to check
        // if the user has the IAP.

        return UserDefaults.standard.bool(forKey: "RemoveAdsPurchased")
    }

    // This will be called by IAPManager
    // when the user sucessfully purchases
    // the IAP
    class func removeAdsSuccess(){
        // This is the code that is run to actually
        // give the IAP to the user!
        //
        // I'm using UserDefaults in this example,
        // but you may want to use Keychain,
        // or some other method, as UserDefaults
        // can be modified by users using their
        // computer, if they know how to, more
        // easily than Keychain

        UserDefaults.standard.set(true, forKey: "RemoveAdsPurchased")
        UserDefaults.standard.synchronize()
    }

    // This will be called by IAPManager
    // when the user sucessfully restores
    //  their purchases
    class func restoreRemoveAdsSuccess(){
        // Give the user their IAP back! Likely all you'll need to
        // do is call the same function you call when a user
        // sucessfully completes their purchase. In this case, removeAdsSuccess()
        removeAdsSuccess()
    }

    // This will be called by IAPManager
    // when the IAP failed
    class func removeAdsFailure(){
        // Send the user a message explaining that the IAP
        // failed for some reason, and to try again later
    }

    // This will be called by IAPManager
    // when the IAP gets deferred.
    class func removeAdsDeferred(){
        // Send the user a message explaining that the IAP
        // was deferred, and pending an external action, like
        // Ask to Buy.
    }

}

public class IAPManager: NSObject, SKProductsRequestDelegate, SKPaymentTransactionObserver{

    // This should the ID of the in-app-purchase you made on AppStore Connect.
    // if you have multiple IAPs, you'll need to store their identifiers in
    // other variables, too (or, preferably in an enum).
    static let removeAdsID = "com.skiplit.removeAds"

    // This is the initializer for your IAPManager class
    //
    // An alternative, and more scaleable way of doing this
    // is to also accept a callback in the initializer, and call
    // that callback in places like the paymentQueue function, and
    // in all functions in this class, in place of calls to functions
    // in RemoveAdsManager.
    let productID: String
    init(productID: String){
        self.productID = productID
    }

    // Call this when you want to begin a purchase
    // for the productID you gave to the initializer
    public func beginPurchase(){
        // If the user can make payments
        if SKPaymentQueue.canMakePayments(){
            // Create a new request
            let request = SKProductsRequest(productIdentifiers: [productID])
            request.delegate = self
            request.start()
        }
        else{
            // Otherwise, tell the user that
            // they are not authorized to make payments,
            // due to parental controls, etc
        }
    }

    // Call this when you want to restore all purchases
    // regardless of the productID you gave to the initializer
    public func beginRestorePurchases(){
        SKPaymentQueue.default().add(self)
        SKPaymentQueue.default().restoreCompletedTransactions()
    }

    // This is called when a SKProductsRequest receives a response
    public func productsRequest(_ request: SKProductsRequest, didReceive response: SKProductsResponse){
        // Let's try to get the first product from the response
        // to the request
        if let product = response.products.first{
            // We were able to get the product! Make a new payment
            // using this product
            let payment = SKPayment(product: product)

            // add the new payment to the queue
            SKPaymentQueue.default().add(self)
            SKPaymentQueue.default().add(payment)
        }
        else{
            // Something went wrong! It is likely that either
            // the user doesn't have internet connection, or
            // your product ID is wrong!
            //
            // Tell the user in requestFailed() by sending an alert,
            // or something of the sort

            RemoveAdsManager.removeAdsFailure()
        }
    }

    // This is called when the user restores their IAP sucessfully
    private func paymentQueueRestoreCompletedTransactionsFinished(_ queue: SKPaymentQueue){
        // For every transaction in the transaction queue...
        for transaction in queue.transactions{
            // If that transaction was restored
            if transaction.transactionState == .restored{
                // get the producted ID from the transaction
                let productID = transaction.payment.productIdentifier

                // In this case, we have only one IAP, so we don't need to check
                // what IAP it is. However, this is useful if you have multiple IAPs!
                // You'll need to figure out which one was restored
                if(productID.lowercased() == IAPManager.removeAdsID.lowercased()){
                    // Restore the user's purchases
                    RemoveAdsManager.restoreRemoveAdsSuccess()
                }

                // finish the payment
                SKPaymentQueue.default().finishTransaction(transaction)
            }
        }
    }

    // This is called when the state of the IAP changes -- from purchasing to purchased, for example.
    // This is where the magic happens :)
    public func paymentQueue(_ queue: SKPaymentQueue, updatedTransactions transactions: [SKPaymentTransaction]){
        for transaction in transactions{
            // get the producted ID from the transaction
            let productID = transaction.payment.productIdentifier

            // In this case, we have only one IAP, so we don't need to check
            // what IAP it is.
            // However, if you have multiple IAPs, you'll need to use productID
            // to check what functions you should run here!

            switch transaction.transactionState{
            case .purchasing:
                // if the user is currently purchasing the IAP,
                // we don't need to do anything.
                //
                // You could use this to show the user
                // an activity indicator, or something like that
                break
            case .purchased:
                // the user sucessfully purchased the IAP!
                RemoveAdsManager.removeAdsSuccess()
                SKPaymentQueue.default().finishTransaction(transaction)
            case .restored:
                // the user restored their IAP!
                RemoveAdsManager.restoreRemoveAdsSuccess()
                SKPaymentQueue.default().finishTransaction(transaction)
            case .failed:
                // The transaction failed!
                RemoveAdsManager.removeAdsFailure()
                // finish the transaction
                SKPaymentQueue.default().finishTransaction(transaction)
            case .deferred:
                // This happens when the IAP needs an external action
                // in order to proceeded, like Ask to Buy
                RemoveAdsManager.removeAdsDeferred()
                break
            }
        }
    }

}

Zuletzt müssen Sie dem Benutzer eine Möglichkeit hinzufügen, den Kauf zu starten und RemoveAdsManager.removeAds() aufzurufen und eine Wiederherstellung zu starten und RemoveAdsManager.restoreRemoveAds() aufzurufen, wie eine Schaltfläche irgendwo! Beachten Sie, dass Sie gemäß den App Store-Richtlinien eine Schaltfläche zum Wiederherstellen von Einkäufen benötigen.

Einreichen zur Überprüfung

Als letztes müssen Sie Ihren IAP zur Überprüfung im App Store Connect einreichen! Ausführliche Anweisungen dazu finden Sie im letzten Teil von meine Ziel-C-Antwort unter Zur Überprüfung einreichen Header.

0
Jojodmo

Ich weiß, dass ich ziemlich spät komme, um dies zu posten, aber ich habe ähnliche Erfahrungen, als ich die Grundlagen des IAP-Modells erlernt habe.

In-App-Käufe sind einer der umfassendsten Arbeitsabläufe in iOS, die von Storekit Framework implementiert werden. Die gesamte Dokumentation ist ganz klar, wenn Sie Geduld haben, sie zu lesen, ist aber technisch etwas fortgeschritten.

Zusammenfassen:

1 - Fordern Sie die Produkte an - verwenden Sie die SKProductRequest & SKProductRequestDelegate-Klassen, um Produkt-IDs anzufordern und von Ihrem eigenen itunesconnect-Store zu erhalten.

Diese SK-Produkte sollten verwendet werden, um Ihre Shop-Benutzeroberfläche zu füllen, mit der der Benutzer ein bestimmtes Produkt kaufen kann.

2 - Zahlungsanforderung ausgeben - Verwenden Sie SKPayment & SKPaymentQueue, um die Zahlung zur Transaktionswarteschlange hinzuzufügen.

3 - Überwachen der Transaktionswarteschlange auf Statusaktualisierung - Verwenden Sie die aktualisierteTransactions-Methode des SKPaymentTransactionObserver-Protokolls, um den Status zu überwachen:

SKPaymentTransactionStatePurchasing - don't do anything
SKPaymentTransactionStatePurchased - unlock product, finish the transaction
SKPaymentTransactionStateFailed - show error, finish the transaction
SKPaymentTransactionStateRestored - unlock product, finish the transaction

4 - Restore-Schaltflächenfluss - Verwenden Sie zum Wiederherstellen die Wiederherstellung von abgeschlossenen Transaktionsvorgängen von SKPaymentQueue. In Schritt 3 wird der Rest erledigt, zusammen mit den folgenden Methoden von SKPaymentTransactionObserver:

paymentQueueRestoreCompletedTransactionsFinished
restoreCompletedTransactionsFailedWithError

Hier ist ein Schritt für Schritt-Tutorial (von mir als Ergebnis meiner eigenen Versuche, es zu verstehen), das es erklärt. Am Ende wird auch ein Codebeispiel bereitgestellt, das Sie direkt verwenden können.

Hier ist ein anderes, das ich geschaffen habe, um bestimmte Dinge zu erklären, die nur Text besser beschreiben könnte.

0
Nirav Bhatt