Tools

Where can I download API or SDK for ONE store?

• You can download SDK or check the list of API at Document > Tools

I was told that some features of an app do not work after an Android API is upgraded. How can I check the version upgrade?

• Before releasing a device with a new OS version, we review once again whether some features of your app do not work after an OS version or an API level is upgraded. We expand and enhance our review (QA) process in an effort to deliver flawless apps to users after the version or level upgrade. Please visit Android version history (here) to view the Android version.

• In addition, you can select and change the OS version. Please refer to App Registration Guide for more details.

I want to know if you provide any update indicators for the apps registered in ONE store.

• Now Update Sync Guide only leads you to the page where you can view whether ONE store Client is installed, and to other details.

• We do not provide any update indicators yet, however we are reviewing to provide the update indicators as fast as possible.

“Android Debug key Signing” pops up while uploading APK.

• Whenever an app is running, development tools (Eclipse, Android Studio) automatically generate a debug signature through the Android SDK.

• And such signature is used whenever the app is used. But if you want to register and sell your Android app in ONE store, you are required to sign your app with private certification key before releasing your app.

• Basically, if you do not sign your app with a debug key while building an Android app, your app might not be installed during the update, or not be released due to the expiration of validity.

• Please ensure that you are required to sign your app with private key and to package it as indicated below.

• Why you are required to use private key signing

  • You can inform users that the app is developed by you and managed with one review

  • You can simplify the contents upgrade.

  • You can implement multiple apps through one process.

  • You can share codes and data

    Signing is to inform that you certify the app. For signing, you need keystore with an encrypted signature file and private key. You can generate a signature by using jarsigner provided by JDK as an open key. For more details, please visit here

How to create keystore and APK, and to sign an app

• Please sign your app after developing Android content, building an app and testing the app to see if it works. You can finalize signing with private key.

• 
• How to sign an app by creating new private key

  • Eclipse > Open Project> Run > Run

  • File > Export > Android > Export Android Application

  • Browse > Select Android Project

  • Create new keystore > Input Location,Password,Confirm

  • Input Alias,Password,Confirm,Validity(years), First and Last Name, Count Code

  • Set location where APK file is stored > Finish

  • 
  • 

• How to sign an app with the current private key

  • Eclipse > Export > Android > Export Android Application

  • Browse > Select Android Project

  • Use existing keystore , Input password (keystore password you entered while creating a new one)

  • Use existing key, Input password (alias password you entered while creating a new one )

  • Set location where APK file is stored > Finish

    

• How to sign an app by creating private key with JDK

  • Execute Command Prompt (Start PC > Execute CMD)

  • Create Key to enter CMD: Create Private Key using CMD keytool Ex) keytool -genkey -v –keystore tstore.mykey -alias mytstore -keyalg RSA -validity 10000 keytool : key creation CMD, keystore : key creation name, alias : false name. Keyalg : algorithm validity : period

  • After key is created, please sign your app with the private key , as explained above, and with Eclipse.

  • Please refer to here URL for more details.

    

Certain resolution error occurs during the review process (QA)

• Basically, we recommend you build your apps based on Android Design Guide to register them in ONE store.

• Please refer to the documents below to develop flexible layouts corresponding to various resolutions and LCDs.

  • Designing for Multiple Screens

  • Building a Dynamic UI with Fragments.

Verification has been rejected due to compatibility issues on the Android 4.0 (Ice Cream Sandwich) device.

• In the Ice Cream Sandwich OS (hereinafter referred to as "ICS") environment, some apps display a specific error message (“Application name” has stopped) and are abnormally terminated during the verification process. Please refer to the cause and countermeasure.

  • Cause : Application execution may be impacted due to the GC's stricter management of exception

    • Common GC-related errors

      • When storing Java objects in the Native area, all objects entering the JNI are local references, so the memory is released when leaving the function. Therefore, objects that need to be continuously referenced from the outside must be declared and managed as global references.

      • When using the return value of FindClass as a global reference, if the value needs to be continuously referenced, you must change it to NewGlobalRef and store it.

      • If JNIEnv is stored and used, JNIEnv cannot be used in other thread contexts.

  • Resolution Guide

    • Check the Java Exception and JNI error messages (JNI ERROR, JNI WARNING) before fixing them

    • Utilize the CheckJNI tool

    • Debugging after disabling the JNI compatibility mode

      • Set targetSdkVersion to 14 (Ice Cream Sandwich) in manifest

        The above analysis was written based on the results of testing and analysis in the ICS environment by randomly selecting published apps on the ONE store Developer Center. In hopes that it will provide guidance for developing and selling apps, we ask that you refer to it when developing ICS-supported apps.

ONE store In-App Purchase

[API V5] When I test my in-app payment with API V5, I see a message saying "Billing has been requested from an unusual app", and I cannot process my payment.

The issue you inquired is a problem that occurs in the commercial review environment or commercial environment. Please check the followings.

• If an app is under development

  • For an app in development, it is recommended for you to proceed with the development by switching to developer mode rather than developing it in the commercial review environment.

  • To switch to the developer mode, please check the guide link below.

    • Guide : Link

• After completing the development

  • If you want to check in the commercial environment after completing the development in the developer mode, please proceed as follows.

  • A. Sign the developed APK using the signing key for distribution and register it in Developer Center.

  • B. Switch the test ID to the commercial ID following the guide below.

    • Guide: Link

  • C. Perform the commercial test by using the apk signed with the same signing key.

  • D. Cancel the billing

• If the APK is registered in Developer Center and the commercial billing is not available,

  • check if the signing key of the APK used for the billing test is the same as the apk registered in ONE store Developer Center.

  • If it is not the same, please sign it with the same key and deliver to Developer Center the apk and test case that generates the issue in the same case.

[API V5] Can I update an app, which was developed with API V4 and previously sold on ONE Store, to API V5?

• ONE store in-app payment API V5 (SDK V17) is not backwards compatible because it was designed with a completely different architecture from the previous version.

• Therefore, the in-app payment API V5 (SDK V17) is only applicable when you register a new product. If the product currently on sale is API V4(SDK V16), please continue to update the product with the corresponding in-app version. ONE store continues to provide the payment service for the in-app payment API V4(SDK V16).

[API V5] The existing API V4 (IAP SDK V16) had an electronic receipt verification feature. Does API V5 provide support for this feature?

• Starting with API V5 (IAP SDK V17), electronic receipts are no longer used, and it is not possible to check payments made on the API V5-based apps by using API V4. API V5 does not provide backwards compatibility. If you're launching an app with new API V5, it can be implemented by using the purchase history check among server APIs or by using the unconsumed product check API among terminal APIs.

• ONE store continues to provide the payment service for the in-app payment API V4(SDK V16).

[API V5] Calling launchLoginFlowAsync without logging in to ONE store app leads to onErrorSecurityException. Why?

• Access was not permitted by the security logic of ONE store service. The up-to-date ONE store service (above 6.064) has solved this problem. Please update ONE store service to the latest version.

[API V5] Under what circumstances does the onErrorRemoteException error occurs?

The onErrorRemoteException occurs when the API is called without binding to ONE store service. You need to check two things below for solution.

• Check if ONE store service normally works.

  • Confirm that the payment window opens normally when purchasing product from ONE store app (no need to pay).

• Check the PurchaseClient life cycle

  • Among the samples provided by ONE store, LuckyActivity.java has a function called initHelper.

  • If you look at the corresponding code, mPurchaseclient.connect is called to connect to ONE store service. Before using the is BillingSupportedAsync API, you need to check if you have worked on that connection. Even if you checked, before calling the API you need to check if there is any case in which mPurchaseClient.terminate(); is called. Because the binding with ONE store service will be explicitly disconnected in the case of terminate.

    mPurchaseClient = new PurchaseClient(this, AppSecurity.getPublicKey());
    // Request a service binding to ONE store service for in-app payment.
    mPurchaseClient.connect(mServiceConnectionListener);

[API V5] In API V4, to access the development mode and commercial mode, the app was built and tested after specifying the connection mode. How can I set the development mode and commercial mode in API V5?

• In API V5, there is no need to set up and build a separate mode for test. You can register test ID in the app in ONE store Developer Center and set the test mode. For details, please refer to ‘Test Purchases & Security’ of the Developer Guides.

[API V5] During the billing test, the message "Service has not allowed" appears and the processing stops. What's the problem?

• You are using a library for API V4 (SDK V16). Please develop by using API V5 (SDK V17).

[API V5] In API V4, the terms, TID and TxID, were used. In API V5, there are many unfamiliar terms such as orderId, purchaseId, and developerPayload. I wonder what each term means and when to use it.

• orderId is an ID that can distinguish payment transactions, such as purchaseId, and can be applied to extended APIs, VOC processing, future additional features, etc.

• orderId and pruchaseId are unique key values of the transaction. They are unchanged, and the two values are matched by 1:1.

• Starting with API V5, the primary key used in the in-app payment I/F has been changed to purchaseId.

• It is recommended to use developerPayload or orderId with no personal information when responding to customer inquiries.

• Currently, the request for checking and cancellation can be made only with TxID(orderId) or TID(developerPayload) through the submenus, such as TxID Search, under the Customer Services menu in Developer Center. As fast as possible, improvements will be made to allow checking/cancellation requests to be made with purchaseId.

• The transaction terms between API V4 and V 5 are matched as follows.

API V4	API V5
TxID	orderId
TID, bpInfo	developerPayload
NA	purchaseId

[API V5] I get the error message “Class cannot be found”.

• It is most likely that the library is misapplied. Especially 16 and 17 have different class configurations, so please check if you use the library for 17.

[API V5] Is there any way for developers to make commercial billing tests with credit cards overseas?

• On ONE store, payment can be made only by using the credit card issued in Korea.

• If the commercial billing test is not possible, please try the Sandbox billing test. There will be no problem in providing service on ONE store even if you only perform the Sandbox billing test.

[API V5] What is a Public Key(License Key)?

• It is the public key used to check the items purchased through in-app payment or to review the purchase history.

• You can check your Public Key at section#4 of Guide Link.

[API V5] Why do you provide NDK for your license key in the Guide?

• Google provides the corresponding key necessary for protection, saying that “instead of inserting the API Key directly in the application code, encryption (for example, an XOR operation) capable of being decrypted is used. Encryption is performed when an application is executed, and a structure for obtaining the key used for encryption from the server is built.”

• To this end, as one of the protection guides, the NDK method is used. Actually, each developer can protect their license key according to their own existing methods.

[API V4] If I fail to get a purchase result response after payment is made, how can I check whether the purchase is made or not?

• When you fail to get a purchase result response after the payment of the app is made, please use Query feature of ONE store IAP API while running the app. After checking if an in-app is successfully purchased, you can deliver the item to users.

• Also, by using the TID purchase history inquiry, which is the Server API, you can check whether the item is paid or not.

[API V4] How to test In-App Purchase

• When you test an in-app, please use JAR files in a dev folder (In-app purchase module for test)

• After the test is completed, please apply JAR files in a release folder (In-app purchase module for release) to binary, and register and request the review of the binary.

  • Self-Test Process

    • Path: Developer Center > Application > My Applications > In App

    • How to conduct Self-Test

      • Enter a test phone number, forms of payment and register the test device at Test Device tab.

      • Conduct the test by setting up various customized results (normal, deactivated from T store, unpublished) at Setting per In-App.

      • Check if an in-app is successfully purchase, and the amount is billed at Billing Logs and Purchase History before complete the test.

      • Apply SO, JAR files in a release folder (In-app purchase module for release), re-compile and request a review.

For more details, including how to register IAP, please refer to IAP Developer Guide and download the check list below to check in advance.

[API V4] How can I unsubscribe the subscription?

• The API does not inform you about the cancellation of the subscription through the in-app purchase module. Please check the expiration date of the in-app verification API.

• After unsubscribing the subscription, you can check the expiration date and remaining subscriptions through the endDate field which are gained in the form of data when the sendCommandRequest is called by the request_purchase_history.

• For more details, please refer to the IAP SDK Reference > sendCommandRequest in the ONE store Developer Center.

[API V4] What is the difference between non-consumable in-apps and other in-apps?

• When people use non-consumable in-apps, in some cases they may need to reinstall the in-apps. So you need to restore non-consumable in-apps after checking the purchase history.

  • (Ex : Non-consumable in-apps cannot be charged when the content is deleted and used again. So you are required to restore the non-consumable in-apps.)

• Please use the query features of the in-app purchase module API while running an app. Please deliver the in-app to users after checking if the in-app is successfully purchased.

  • Query features : auth_item, whole_auth_item, etc.

  • For more details, including error codes, please refer to IAP SDK Reference in the ONE store Developer Center.

[API V4] Non-consumable in-app is charged whenever the in-app is tested. It seems that the in-app does not have rollback methods.

• For convenience of product payment test and development, it is possible to duplicate purchases only in development environment. When applying commercial In-App payment module, it is possible to make the first purchase once, and the pop-up that can not be purchased will be exposed after purchase.

[API V4] How many points are deducted when the item_use or the subtract_points method is used?

• One point is deducted when the item_use or the subtract_points method is used.

[API V4] When I use an electronic receipt verification interface, I continue to get “Required parameters lack” message.

• Electronic receipt validation must be implemented by creating a JSON object and requesting the e-receipt validation server to POST the contents of the JSON object in the http body part. When requesting the electronic receipt verification, appid, txid, and signdata are requested in the post method of JSON format, and the content-type value of the http header value is set to application / json and then proceed the verification request.

JSONobject json = new JSONObject(); // Create JSON object
json.put("appid","OA00123456");
json.put("txid", txid);
json.put("signdata", signdata); // Complete creating JSON object for request
 
HttpClient client = new DefaultHttpClient();
HttpPost httpPostRequest = new HttpPost("https://iapdev.tstore.co.kr/digitalsignconfirm.iap");
StringEntity se = new StringENtity(json.toString(), "UTF-8");
 
httpPostRequest.setEntity(se); // Set String object for request
httpPostRequest.setHeader("Content-Type", "application/json"); // Set Header
 
HttpResponse resp = client.execute(httpPostRequest); // Receive a response after electronic receipt verification request

How can I escape conflicts when I apply Proguard?

• You can escape conflicts by referring to the proguard config as seen below when Proguard is applied to the latest in-app in ONE store.

  • proguard config: An in-app works when the items below are added to the Proguard-project.txt.

JSONobject json = new JSONObject(); // Create JSON object
json.put("appid","OA00123456");
json.put("txid", txid);
json.put("signdata", signdata); // Complete creating JSON object for request
 
HttpClient client = new DefaultHttpClient();
HttpPost httpPostRequest = new HttpPost("https://iapdev.tstore.co.kr/digitalsignconfirm.iap");
StringEntity se = new StringENtity(json.toString(), "UTF-8");
 
httpPostRequest.setEntity(se); // Set String object for request
httpPostRequest.setHeader("Content-Type", "application/json"); // Set Header
 
HttpResponse resp = client.execute(httpPostRequest); // Receive a response after electronic receipt verification request

• In addition, when you use the utility package (com.skplanet.dev.guide.helper, com.skplant.dev.guide.pub, gson-2.2.2.jar) of Sample App(iap_api_sample), please add the items below in order not to apply Proguard to the GSON related class.

-keep class com.google.gson.**{*;}
-keep class com.skplanet.dev.guide.pdu.**{*;}

I want to get a quick reply for library-related issues only.

• If you have any IAP library-related inquiries, please send the information below to [e-mail]. We will address your issues and support you as fast as possible after receiving your inquiry.

Related to IAP Library issues

1. Application ID

2. App Title

3. PID

4. Time when Error Occurred

5. Cell Phone Number used for the Billing Test

6. Cell Phone Model and Android OS Version used for the Test

7. All Error Log

8. Excerpt IAP Library-applied Source

9. Explain Flow of IAP Library Implementation Logic and Activity

10. Path which leads to Errors (including Error Screen Shot)

11. Whether Application ID within the source and PID are correctly entered.

12. Library Version (ex : V12.09.17, V13.00.00,etc)

13. Library Type (ex : For Test, For Release)

14. Whether ProGuard is applied.

15. App Development Platform (ex : Android, Adobe Air, Corona, Cocos2d-x, Unity 3D , etc)

16. APK File

17. Inquiry

Related to Electronic Signature Receipt Error

1. Application ID

2. App Title

3. PID

4. Time when Error Occurred

5. Cell Phone Number used for the Billing Test

6. Cell Phone Model and Android OS Version used for the Test

7. All Error Log

8. Request Information for Electronic Receipt

9. Inquiry

[API V4] How can I conduct a self-test if I do not have the device produced in Korea?

• Prepare a cell phone equipped with USIM

• Download and install ONE store In-App Purchase SDK

• Download and install IAP Setting App Set parameter options as 'development' at IAP Setting App

• Register a test phone number at the self-test page

• After running IAP Setting App, set and use the test phone number already registered at the self-test page (You can randomly select mobile carriers)

• After setting preferences of In-App status and conduct the self test

• When the self test is completed, set your parameter options as 'release' mode and request a review

[API V4] While an in-app is being tested, “The in-app is not published, or it is in review” pops up.

• The message above pops up when you apply SO, JAR files in a release folder (In-app purchase module for release) to the in-apps in review. The test works if you decompress the in-app purchase module and apply SO, JAR files in a dev folder.

[API V4] I register points at the self test page. But the points are not displayed.

• You are required to apply SO, JAR files in a dev folder (In-app purchase module for test) and build an in-app. Please select “Search” button at the in-app purchase page, sync it to “Search Point” and choose “Use”. Then you can use the points.

[API V4] How to use TID purchase history URL search

If the purchase history search request URL is in the format of IP:PORT, we recommend you change the format to Domain:PORT

• For Test : https://iapdev.tstore.co.kr:8082/billIntf/billinglog/billloginquiry.action

• For Release : https://iap.tstore.co.kr:8090/billIntf/billinglog/billloginquiry.action

How can I change the title and price of an in-app?

• Except the price, you can edit or delete metadata of your in-app items such as title. In-App item price can be modified at any time if the sales status is registered. If it is prohibited during sale / suspension, it can be changed once a week.

A validation error (9113) is returned when an electronic receipt validation request is made.

• The in-app purchase module does not support the creation of TID. You need to generate a unique TID in the app or the app server, and request a purchase history search. We recommend you create a TID in the app server rather in the app where sometimes a TID is not unique when created.

When I request electronic receipt verification, invalidation error (9113) occurs.

Please read the descriptions below.

• Check if the signdata is successfully delivered.(App Server -> In-App Payment Server, App -> App Server)

• Check if there is space in the signdata.

• Check if other characters (special characters, ex:+, etc) are included in the signdata when it is saved.

[API V4] If I fail to get a purchase result response after payment is made, how can I receive an electronic receipt?

• Reissuance of electronic receipt is not technically possible. It is recommended to call the request_purchase_history API provided by SDK as a defense logic or to use the Server API 'TID purchase history inquiry' interlocking when it may not be able to give items to user in case the electronic receipt can not be obtained.

In case switch the screen mode between portrait to landscape, In-App purchase screen does not work properly

• ONE store IAP purchase need to re-draw its purchase display when user switch display mode this effect might be happen.

• So developer need to fix switching screen mode when ONE store IAP module executable at your application. Please read detail technical like below and apply it to your androidmenifext.xml.

• Technical Guide

It says that in-app payment for the old version of the in-app is no longer available. What qualifies as the old version?

• The old version of the in-app SDK, which was discontinued at the end of 2015, refers to the version with a black payment window as shown in the image below.

• If the webview-based payment window appears, it has not been stopped.