Forem: Makarov

How to Add An App to the Google Play Store? Solving Problems With Publishing Apps

Makarov — Wed, 08 Feb 2023 08:57:13 +0000

The Android operating system is actively used in over 190 countries in the world, with over 1 billion users. Google Play Store is the largest application store globally, home to over 3 million android applications. With its large user base, hosting apps on Google Play Store is one of the best ways to generate income as an Android developer. There may be some issues with hosting that affect your app and your relationship with Google Play. In this article, we will walk you through the process of adding apps to Google Play. We will also discuss possible problems when publishing applications and their prevention. At the moment, one of the most popular placement problems is the ban of an application or account.

How to Add an App to the Google Play Store

1) Create a Google Developer Account: You can create a Google developer account, using an already existing Google account or setting up a new one. Once you have signed in with your Google account, proceed to accept the terms. It usually takes 48 hours for a developer account to be approved.

Link Your Google Merchant Account: If you will be making purchases and payments in your app, you need a merchant account. This account will enable you to track sales and other metrics.

2) Create Your Application: Go to your Google Developer page. On the page, click on “Create Application”. Add your language and a brief description before clicking on “Create”.

3) Store List Your Application: The next step is store-listing your application. To do this, you need to provide information about your application (its name, multiple and long description, application icon, etc). The specification for each item is stated in the guidelines.

4) Content Rating: Passing a rating questionnaire is important to avoid being flagged as an unrated app. Make sure to provide accurate information about your app when answering the questionnaire. Any details that do not match what your app offers, might lead to removal from the Google Play Store. Answer the questions and click on “Save Questionnaire”. Follow this by clicking on “Calculate Rating”, this will provide you with a rating. Complete this step by clicking on “Apply Rating” to complete the content rating.

5) Pricing: Pricing your application is straightforward. Simply answer the questions that are provided.

6) Submit Your Application for Publishing: To submit your application, you need to upload it in ABB or APK format. Your application should not exceed 100MB in size. Submit in Alpha, Beta, or Production mode, which will be followed by a Google review. The application review typically takes up to 7 days, after which your app is published.

Common Issues That Come With Publishing Apps on the Google Play Store

Some developers have difficulty publishing their apps on Google Play for the following reasons.

- Broken Functionality: The goal of Google Play is to provide users with only the best products. Therefore, applications with broken features are often rejected by the store. Before publishing, it is always worth checking that all the features of your app work correctly.

Bugs and Errors: A buggy app is a user’s nightmare. Bugs and errors are known to make applications crash, thereby affecting the overall user experience. Naturally, Google rejects applications with such violations. You should always check your applications for bugs and errors before publishing.
Uniqueness: Uniqueness is the main criterion for approving applications on the Google Play Store. Similarities between code, design, and concept can result in your app being marked as spam and subsequently banned. The best way to deal with this problem is to create a unique code for your applications.

Creating Unique Applications with AppRefactoring

In the process of writing applications, developers can borrow code from their old programs and this is normal. Old code helps when there is a shortage of resources that are not enough to create a new one, or when you need to rewrite the system from scratch, the developer can simply integrate the old code into the new application. In addition, by creating similar applications (for example, two versions of the photo editor), the developer can use the same source code to write them. This is done to make your job easier. But, as a result, such actions lead to code duplication, which Google Play can easily mark as "non-unique" code, and this leads to a ban of the application/account.
To avoid such problems on Google Play, it is still worth creating unique applications. It is better to spend time on a unique code than to deal with a ban from Google Play.
If time is still your priority, you can use a special tool that helps you create a unique source code. AppRefactoring analyzes the downloaded code and gives recommendations for its uniqueness. With the help of refactoring and obfuscation, you can create code in a couple of clicks that can avoid getting banned from Google Play. The AppRefactoring tool will compare between your codebase, showing any intersections. This ensures that you will be able to host unique and functional applications approved by Google Play.
AppRefactoring also supports 9 programming languages: Java, JavaScript, TypeScript, C#, GO, Objective-C, PHP, Swift, Kotlin, so it is suitable for most programmers.

Conclusion

Now you know how to submit your product to the Android app store and what information is needed to do so. You also know that there are a number of problems (functionality violation, presence of bugs and errors, uniqueness problem) that lead to difficulties in working on Google Play, and the “uniqueness” problem can lead your application or account to be banned.
For this reason, it is worth creating unique applications that will be protected from the Google Play ban. To create a unique code, the AppRefactoring tool will help you, which will simplify your work and show great results in a short time. The tool will analyze the code, compare it with your entire/team database, and make recommendations for creating unique code. All these processes accelerate the development and release of applications to the site.

Write in the comments your experience with placing applications on the Android platform.

How to eliminate code duplicates in Java?

Makarov — Wed, 18 Jan 2023 14:11:51 +0000

A Java developer's job doesn't end with writing code. The developer must ensure that the code is structured and functional. Removing duplicate code fragments from the program is an important step in the process of software development and maintenance.

It is worth mentioning that removing the duplicate code can be a laborious process. Still, it is essential to remember that it will improve the maintainability of the code and also reduce the risk of introducing errors and bugs. This can be achieved by using special tools for working with code. You should analyze your code and then refactor it to improve its quality.

The processes of analysis and refactoring improve the internal structure of the code and get rid of "smells", for example, as duplicated code fragments. This allows you to keep the code up-to-date and add new functions without problems.

Code Analysis for Java

Code analysis is one of the steps in writing good code. Code analysis involves reviewing and evaluating the program to identify areas with bugs, bugs, security vulnerabilities, and other problems.

Manual code analysis. This is code analysis line by line, performed by a software developer who specializes in code analysis. The process usually takes much time;
Automated static analysis. The process involves using automated tools, such as SonarQube, which will save you time. The tools analyze the code without running it.
Automated dynamic analysis. It involves monitoring the code being executed to detect errors, bugs, and potential vulnerabilities.
Hybrid approach. This method combines automated static and dynamic code analysis and its manual check.

There is also a new AppRefactoring tool on the market that analyzes the code and makes it unique. This tool will also help you in eliminating duplicates from your Java code.
Based on the results of the analysis, you can perform refactoring for the source code.

How can refactoring help?

Refactoring is changing the internal structure of Java code without changing its functionality. This process has many benefits that help the Java developer improve the quality of his code. We will cite four reasons:

Clean code, refactoring helps eliminate code smells and extract duplicate fragments.
Bug detection and correction. Refactoring makes code easier to understand, which makes it easier to find bugs in it.
Ease of maintenance. Conducting regular refactoring makes it easier to maintain the code.
Saving time and energy, refactoring Java code improves code quality without having to rewrite it. This will save your resources.

Example of refactoring for Java

For example, there is a method that compares two numbers and returns true if the first is greater and false otherwise:
public boolean max(int a, int b) { if(a > b) { return true; } else if(a == b) { return false; } else { return false; } }
This is quite a lot of code. It would seem that there is no need for the if-else block when you can write a method 6 lines shorter:
public boolean max(int a, int b) { return a>b; }
This way the code looks much easier, although it does the same action as above.
Automated code uniqueness tool for Java
Conducting analysis manually is a tedious task that consumes time and resources. In addition, it can lead to additional errors in the software. That's why you need an automated tool that can help ensure speed and improve your performance. Consider AppRefactoring, an automated analysis tool that effectively helps you work with Java code.

With AppRefactoring, you can perform a detailed analysis of your code in a few clicks. The result of the analysis gives you information about problems in your code and fragments that need to be unique. Your code is compared to other projects in your database for uniqueness, notifying you of any overlaps. While AppRefactoring analyzes and compares your projects, you can focus on your other tasks.

Conclusion

Refactoring is a tool that every Java developer needs because no code is perfect. By refactoring your code regularly, you get to keep it readable and clean, and functioning at the highest level. It is necessary to analyze the code to fix its errors and bugs. For analysis, it's better to use the special tools mentioned above. SonarQube, which can perform automated analysis for code. AppRefactoring - this will not only help you to analyze but will also help to make your code unique. With these tools, you won't have to worry about the long hours required to manually work with your code. AppRefactoring will help you quickly analyze your code with all the possible exceptions.

Application ban, how to avoid?

Makarov — Thu, 15 Dec 2022 06:42:04 +0000

The App Store and Play Market statistics show that the number of applications getting banned is growing daily, and every developer is faced with the fact that the project they worked hard on and put their whole effort into has been banned. We have personally experienced this problem from popular mobile platforms and know what to do about it. But first, you need to understand the reasons for the ban.

Reasons for a ban from the App Store and Play Market

An application can be banned for many reasons, but let's consider the reasons associated with the application code.

Similar/copied/duplicated source code, the main reason for blocking accounts or applications. Such a code gets to you if you use the services of freelancers. Most often, such developers simply copy/download the code for their customers to give it away and get paid faster. Another way is the company uses the services of one programmer and he makes changes to the source using his style. Therefore, one code is practically no different from another, and the algorithms of mobile platforms pay attention to this and read it as plagiarism.
Multi-accounting is another popular reason for a ban. Multi-accounting - the ability to register multiple accounts, one user on one platform. For example, a company/developer releases similar applications, so that they can reach mobile platforms faster, they use different accounts for this. You can link these accounts responsibly according to different criteria, but the most common reason is the same code. That is, the written code of the new application is similar to the code that the company/developer has already released using the second account. The App Store and Play Market do not welcome such actions, since most often they violate the policies of their companies, which leads to a ban. Because, on their part, it is considered copied/duplicated code.

To eliminate the causes of the ban, companies or developers use code refactoring and obfuscation. That is, they analyze it and work on the uniqueness, quality, and purity of the code, each stage requires a lot of attention. This is how a large resource of time and invested finances is spent on projects that were not originally calculated.

Personal experience - avoiding a ban!

Our team has been working since 2012 to create mobile applications for the App Store and Play Market. In the process of creation, we use modern technologies, a special approach, and different types of tasks. At one point in 2017, our apps started getting banned due to multi-accounting, over 50 accounts and 1500 apps were banned in 3 minutes.

The whole problem was in the source code, or rather its identity, we began to solve the problem manually, refactoring and obfuscating the code ourselves. So we worked for several years, but all this time it took too much time for these tasks. Manual refactoring and obfuscation could take from 2-3 days, and sometimes it took as much time as it takes to create a new application. This hurt the timing of orders and the cost of production of the application.
Using these methods, we worked until we received a new ban, which was again linked to the source of the application. In 2019, the number of applications that got banned was more than 400. The problem was not solved, and we realized that we needed a tool to work with the code, analyze it, and which would be completely automatic. Because our team creates a large number of different projects, there is simply no way to remember everything.
Taking experience as a basis, understanding the problems that may be encountered. We started creating our tool that will help with the analysis of the source code to see how it matches with the base of finished applications at the initial stage. The ability to compare between applications helps to eliminate the likelihood of getting banned up to 90% from IOS and Android when replacing the structure of identical files, methods, and variables. Plus, these factors are supplemented by the algorithms of the App Store and Play Market, which do not stand still, and every time you have to find new options for creating applications to meet the requirements.
This is how the history of the service began, we have been working on it since 2020 and improving its capabilities every day. When we had confidence in its reliability and stability, we decided to open access to other users. Because we understand that we are not the only ones who have similar problems when creating applications. Your AppRefactoring can personally get acquainted with our tool ”.

Bottom line: By choosing manual code refactoring, you are helping your applications, but you are wasting a lot of resources. This process should be a stable part of the work, so for convenience, it is worth using the tool -“AppRefactoring”, in one click, the robot analyzes the source code, shows the mistakes made and can compare with your personal or team projects (if you are not working alone). The result shows the percentage of code uniqueness and qualitative analysis, you can save personal and team resources (time, money, as well as nerves).

Be sure to share your cases in the comments, we need to learn about the experience of each reader! Plus it can be a good example for others!

How is this dirty code

Makarov — Mon, 12 Dec 2022 13:09:23 +0000

I started writing code in Swift, now when the application is launched, its functionality does not work well. I surfed the Internet for possible causes and came across information about dirty code and its refactoring. Who did the refactoring for the source code? Does this help solve the issue with the functionality?
Here is the code:
`//
// proSwift.ru
//
// Swift 3

init?(brand: String) {
    if let oil = MotorOil(rawValue: brand) {
        self.oilBrand = oil
    } else {
        return nil
    }
}`

How to refactor for js

Makarov — Thu, 08 Dec 2022 08:15:40 +0000

Hello, there is a poorly written product price change function that takes into account many different conditions. It is worth refactoring, as the function itself is poorly readable. Tell me where and what is better to read or what practices to use. Here is the function for clarity (sorry in advance):
`function changePrice($this = null) {
if ($this == null) {
var rel_price = $('.all_colors_preview.active#rel_colors').find('.item.active .price').attr('data-price'),
option_price = $('.all_colors_preview.active#option_colors').find('.item.active .option-price').val(),
prefix = $('.all_colors_preview.active#option_colors').find('.item.active .option-price-prefix').val(),
price_current = $('.price_wrapper .price_current'),
option_sizes = $('.option_size.active'),
quantity = Number($('#inner .quantity_val').text());
} else {
var rel_price = $this.find('#rel_colors.active .item.active .price').attr('data-price'),
option_price = $this.find('#option_colors.active .item.active .option-price').val(),
prefix = $this.find('#option_colors.active .item.active .option-price-prefix').val(),
price_current = $('.price_wrapper .price_current'),
option_sizes = $this.find('.option_size.active'),
quantity = Number($this.find('.quantity_val').text());
}

if (!quantity) {
quantity = Number($('#inner .quantity_val').text());
}

var current = Number(price_current.attr('data-original-price'));

if (rel_price != '' && rel_price != undefined) {
price_current.attr('data-update-price', rel_price);
updated = Number(price_current.attr('data-update-price')) * quantity;
updated = String(updated).replace(/(\d)(?=(\d\d\d)+([^\d]|$))/g, '$1 ')
price_current.text(updated + ' ₽');
} else if (option_price != '' && option_price != undefined && prefix != '') {
if (prefix == '+') {
update_price = current + Number(option_price);
} else {
update_price = current - Number(option_price);
}

price_current.attr('data-update-price', update_price);
update_price = quantity * price_current.attr('data-update-price');
price_current.text(String(update_price).replace(/(\d)(?=(\d\d\d)+([^\d]|$))/g, '$1 ') + ' ₽');

} else if (option_price == '') {
price_current.attr('data-update-price', current);
current *= quantity;
price_current.text(String(current).replace(/(\d)(?=(\d\d\d)+([^\d]|$))/g, '$1 ') + ' ₽');
} else {
return false;
}

if (option_sizes && option_sizes.length) {
if (price_current.attr('data-update-price')) {
current = Number(price_current.attr('data-update-price'));
}
var option_prefix = option_sizes.find('input[type="hidden"]').attr('data-prefix'),
option_size_price = option_sizes.find('input[type="hidden"]').attr('data-price');
if (option_prefix == '+') {
update_price = current + Number(option_size_price);
} else {
update_price = current - Number(option_size_price);
}

price_current.attr('data-update-price', update_price);
update_price = quantity * price_current.attr('data-update-price');
price_current.text(String(update_price).replace(/(\d)(?=(\d\d\d)+([^\d]|$))/g, '$1 ') + ' ₽');

}
}`