Android
In-App-Abrechnung
Suche…
Verbrauchbare In-App-Käufe
Verbrauchsfähige verwaltete Produkte sind Produkte, die mehrmals gekauft werden können, wie beispielsweise Spielwährung, Spieldauer, Power-Ups usw.
In diesem Beispiel werden 4 verschiedene verwaltete Verbrauchsmaterialien "item1", "item2", "item3", "item4" .
Schritte in Zusammenfassung:
- Fügen Sie Ihrem Projekt die In-App-Abrechnungsbibliothek hinzu (AIDL-Datei).
- Fügen Sie die erforderliche Berechtigung in der Datei
AndroidManifest.xml.- Stellen Sie eine signierte apk für Google Developers Console bereit.
- Definieren Sie Ihre Produkte.
- Implementieren Sie den Code.
- Testen Sie die In-App-Abrechnung (optional).
Schritt 1:
Zuerst müssen wir die AIDL-Datei zu Ihrem Projekt hinzufügen, wie in der Google-Dokumentation hier klar beschrieben.
IInAppBillingService.aidl ist eine AIDL-Datei (Android Interface Definition Language), in der die Schnittstelle zum In-App-Abrechnungsdienst der Version 3 definiert wird. Sie verwenden diese Schnittstelle, um Abrechnungsanforderungen durch Aufrufen von IPC-Methodenaufrufen auszuführen.
Schritt 2:
Fügen Sie nach dem Hinzufügen der AIDL-Datei die BILLING-Berechtigung in AndroidManifest.xml :
<!-- Required permission for implementing In-app Billing -->
<uses-permission android:name="com.android.vending.BILLING" />
Schritt 3:
Generieren Sie eine signierte apk und laden Sie sie in die Google Developers Console hoch. Dies ist erforderlich, damit wir unsere In-App-Produkte dort definieren können.
Schritt 4:
Definieren Sie alle Ihre Produkte mit einer anderen productID und legen Sie für jedes Produkt einen Preis fest. Es gibt zwei Arten von Produkten (verwaltete Produkte und Abonnements). Wie bereits erwähnt, werden wir 4 verschiedene verwaltete Verbrauchsmaterialien "item1", "item2", "item3", "item4" .
Schritt 5:
Nachdem Sie alle oben genannten Schritte ausgeführt haben, können Sie nun den Code selbst in Ihre eigene Aktivität implementieren.
Hauptaktivität:
public class MainActivity extends Activity {
IInAppBillingService inAppBillingService;
ServiceConnection serviceConnection;
// productID for each item. You should define them in the Google Developers Console.
final String item1 = "item1";
final String item2 = "item2";
final String item3 = "item3";
final String item4 = "item4";
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// Instantiate the views according to your layout file.
final Button buy1 = (Button) findViewById(R.id.buy1);
final Button buy2 = (Button) findViewById(R.id.buy2);
final Button buy3 = (Button) findViewById(R.id.buy3);
final Button buy4 = (Button) findViewById(R.id.buy4);
// setOnClickListener() for each button.
// buyItem() here is the method that we will implement to launch the PurchaseFlow.
buy1.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
buyItem(item1);
}
});
buy2.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
buyItem(item2);
}
});
buy3.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
buyItem(item3);
}
});
buy4.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
buyItem(item4);
}
});
// Attach the service connection.
serviceConnection = new ServiceConnection() {
@Override
public void onServiceDisconnected(ComponentName name) {
inAppBillingService = null;
}
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
inAppBillingService = IInAppBillingService.Stub.asInterface(service);
}
};
// Bind the service.
Intent serviceIntent = new Intent("com.android.vending.billing.InAppBillingService.BIND");
serviceIntent.setPackage("com.android.vending");
bindService(serviceIntent, serviceConnection, BIND_AUTO_CREATE);
// Get the price of each product, and set the price as text to
// each button so that the user knows the price of each item.
if (inAppBillingService != null) {
// Attention: You need to create a new thread here because
// getSkuDetails() triggers a network request, which can
// cause lag to your app if it was called from the main thread.
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
ArrayList<String> skuList = new ArrayList<>();
skuList.add(item1);
skuList.add(item2);
skuList.add(item3);
skuList.add(item4);
Bundle querySkus = new Bundle();
querySkus.putStringArrayList("ITEM_ID_LIST", skuList);
try {
Bundle skuDetails = inAppBillingService.getSkuDetails(3, getPackageName(), "inapp", querySkus);
int response = skuDetails.getInt("RESPONSE_CODE");
if (response == 0) {
ArrayList<String> responseList = skuDetails.getStringArrayList("DETAILS_LIST");
for (String thisResponse : responseList) {
JSONObject object = new JSONObject(thisResponse);
String sku = object.getString("productId");
String price = object.getString("price");
switch (sku) {
case item1:
buy1.setText(price);
break;
case item2:
buy2.setText(price);
break;
case item3:
buy3.setText(price);
break;
case item4:
buy4.setText(price);
break;
}
}
}
} catch (RemoteException | JSONException e) {
e.printStackTrace();
}
}
});
thread.start();
}
}
// Launch the PurchaseFlow passing the productID of the item the user wants to buy as a parameter.
private void buyItem(String productID) {
if (inAppBillingService != null) {
try {
Bundle buyIntentBundle = inAppBillingService.getBuyIntent(3, getPackageName(), productID, "inapp", "bGoa+V7g/yqDXvKRqq+JTFn4uQZbPiQJo4pf9RzJ");
PendingIntent pendingIntent = buyIntentBundle.getParcelable("BUY_INTENT");
startIntentSenderForResult(pendingIntent.getIntentSender(), 1003, new Intent(), 0, 0, 0);
} catch (RemoteException | IntentSender.SendIntentException e) {
e.printStackTrace();
}
}
}
// Unbind the service in onDestroy(). If you don’t unbind, the open
// service connection could cause your device’s performance to degrade.
@Override
public void onDestroy() {
super.onDestroy();
if (inAppBillingService != null) {
unbindService(serviceConnection);
}
}
// Check here if the in-app purchase was successful or not. If it was successful,
// then consume the product, and let the app make the required changes.
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
if (requestCode == 1003 && resultCode == RESULT_OK) {
final String purchaseData = data.getStringExtra("INAPP_PURCHASE_DATA");
// Attention: You need to create a new thread here because
// consumePurchase() triggers a network request, which can
// cause lag to your app if it was called from the main thread.
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
try {
JSONObject jo = new JSONObject(purchaseData);
// Get the productID of the purchased item.
String sku = jo.getString("productId");
String productName = null;
// increaseCoins() here is a method used as an example in a game to
// increase the in-game currency if the purchase was successful.
// You should implement your own code here, and let the app apply
// the required changes after the purchase was successful.
switch (sku) {
case item1:
productName = "Item 1";
increaseCoins(2000);
break;
case item2:
productName = "Item 2";
increaseCoins(8000);
break;
case item3:
productName = "Item 3";
increaseCoins(18000);
break;
case item4:
productName = "Item 4";
increaseCoins(30000);
break;
}
// Consume the purchase so that the user is able to purchase the same product again.
inAppBillingService.consumePurchase(3, getPackageName(), jo.getString("purchaseToken"));
Toast.makeText(MainActivity.this, productName + " is successfully purchased. Excellent choice, master!", Toast.LENGTH_LONG).show();
} catch (JSONException | RemoteException e) {
Toast.makeText(MainActivity.this, "Failed to parse purchase data.", Toast.LENGTH_LONG).show();
e.printStackTrace();
}
}
});
thread.start();
}
}
}
Schritt 6:
Nachdem Sie den Code implementiert haben, können Sie ihn testen, indem Sie Ihre APK im Beta- / Alphakanal bereitstellen und andere Benutzer den Code für Sie testen lassen. Im Testmodus können jedoch keine echten In-App-Käufe getätigt werden. Sie müssen Ihre App / Ihr Spiel zunächst im Play Store veröffentlichen, damit alle Produkte vollständig aktiviert sind.
Weitere Informationen zum Testen der In-App-Abrechnung finden Sie hier .
In-App v3-Bibliothek von Drittanbietern
Schritt 1: Führen Sie zunächst die folgenden zwei Schritte aus, um die App-Funktionalität hinzuzufügen:
1. Fügen Sie die Bibliothek mit folgendem Befehl hinzu:
repositories {
mavenCentral()
}
dependencies {
compile 'com.anjlab.android.iab.v3:library:1.0.+'
}
2. Fügen Sie die Berechtigung in der Manifestdatei hinzu.
<uses-permission android:name="com.android.vending.BILLING" />
Schritt 2: Initialisieren Sie Ihren Rechnungsprozessor:
BillingProcessor bp = new BillingProcessor(this, "YOUR LICENSE KEY FROM GOOGLE PLAY CONSOLE HERE", this);
und implementieren Sie Billing Handler: BillingProcessor.IBillingHandler, der 4 Methoden enthält: a. onBillingInitialized (); b. onProductPurchased (String productId, TransactionDetails-Details): Hier müssen Sie Aktionen ausführen, die nach einem erfolgreichen Kauf ausgeführt werden sollen. c. onBillingError (int errorCode, Throwable-Fehler): Behandlung von Fehlern, die während des Kaufvorgangs aufgetreten sind. d. onPurchaseHistoryRestored (): Zum Wiederherstellen in App-Käufen
Schritt 3: Wie kaufe ich ein Produkt?
So kaufen Sie ein verwaltetes Produkt:
bp.purchase(YOUR_ACTIVITY, "YOUR PRODUCT ID FROM GOOGLE PLAY CONSOLE HERE");
Und um ein Abonnement zu erwerben:
bp.subscribe(YOUR_ACTIVITY, "YOUR SUBSCRIPTION ID FROM GOOGLE PLAY CONSOLE HERE");
Schritt 4: Ein Produkt konsumieren.
Um ein Produkt zu konsumieren, rufen Sie die consumePurchase-Methode auf.
bp.consumePurchase ("IHRE PRODUKT-ID VON GOOGLE PLAY CONSOLE HERE");
Für andere Methoden in der App besuchen Sie github