Setup Processing for Android Application development : Android Training in Chandigarh

Let us learn the important techniques before starting the android application development what setup processing user need with android training in Chandigarh.

Preparing for Android venture is mean to make it absurdly simple to make Android applications utilizing the Processing API.

To setup Processing development tool for Android Application development, you have to install Android Developer Tools (ADT) in your system in advance.

Also you have to configure your Android SDK Manager to install Android 2.3.3 (API 10) – in Eclipse for Android Developer Tools, select Window -> Android SDK Manager:

otherwise you will have error of Unable to resolve project target ‘android-10’ when compile your Processing sketch.

Setup Processing for Android Application development: These are steps which you have to follow during the setup processing of android application development.

Start Processing software:

1. – In Ubuntu, open Terminal, switch to your installed directory of Processing, type the command:
2. $./processing
3. – Select Add Mode in the Top-Right pull-down box.
4. – Select Android Mode, and click Install.
5. – You will be asked to select Android SDK installed location, click Yes.
6. – In the next dialog, select your installed location of Android SDK.

In my case of running on Ubuntu 13.04 with Xubuntu desktop, I cannot open sub-directory of Android in Folders box by clicking on Android, but I can direct enter Android/sdk/ in Selection box.

– Now you can switch to Android Mode in Top-Right pop-down box.

Next Topic we will discuss about Autoboxing in android application development with android training in chandigarh.

What issues auto boxing made on android application development? 

Autoboxing, a seemingly insignificant detail, can cause enormous issues for Android Application development Performance. To guarantee your application performs well over a wide assortment of gadgets, you generally attempt to utilize best practices. On that front memory advancement is regularly a requesting assignment. More often than not we generally think on its greater side and miss the little thing that can mean a major issue. Autoboxing is a theme that frequently goes unnoticed when discussing execution issues.

Autoboxing is an extraordinary dialect highlight, until the point when you understand the amount of your execution is being lost to its benefit. You can’t envision a straightforward Autoboxing activities can without much of a stretch tear through your Application’s memory.

What is Autoboxing?

Till JDK 1.4, when we work with crude kinds, it requires tedious work of changing over the crude sorts into wrapper classes and the other way around. Suppose on the off chance that we need to make a List with Integers, we need to unequivocally wrap them as Integer and we have to unwrap it to get int esteem.

So since JDK 1.5, Conversion from crude sorts to relating wrapper articles and the other way around can happen consequently.

Boxing: Conversion of a crude sort to the relating reference write (int – > Integer).

Unpacking: Conversion of the reference compose to the relating crude write (Integer – > int).

How it causes issue?

As we examined Java gives relating wrapper classes that match crude writes, and go about as question wrappers. These classes give an indistinguishable functionalities from natives yet can be utilized with non specific accumulations. Anyway their size in memory isn’t the same. An Integer question possesses 4 times more memory as crude int.

In the case beneath, the API call including a crude int esteem yet the accumulation API takes Integer question. This task will play out an Autoboxing activity from int to Integer question.

/Here is crude variable

int esteem = 5;

List<Integer> list = new ArrayList<>();

/autoboxing to include crude write (int) in accumulation class

list.add(value);

For a solitary call, this may not make any difference much. Nonetheless, on the off chance that we are utilizing it oftentimes, for instance in an internal circle, it may involve a great deal of memory superfluously and cause a major memory threat.​

/Here is non specific variable

Whole number aggregate = 0;

for(int i= 0;i< 100;i++){

/autoboxing to change over int into Integer

total = aggregate + I;

}

As should be obvious in the above case, 100 new questions portion alongside the aggregate estimation. Be that as it may, if there should be an occurrence of crude it doesn’t require any extra allotment overhead.

This will likewise overhead of more trash accumulation and reduction the runtime execution. It can be particularly agonizing with information structures like HashMap. We should think about another code:

HashMap<Integer, String> outline new HashMap< >();

/Put the incentive in the guide where key is crude write.

map.put(1, “TestValue”);/expected key is Integer compose

/Get the incentive from the guide where key is crude write.

map.get(1);/expected key is Integer compose

In the above code put and get tasks will utilize Autoboxing and cause extra load. Essentially whenever you embed, refresh or recover an incentive with this non specific holder when a crude is included you wind up boxing or unpacking esteems.

How to determine the issue?

To decide the issue of autoboxing Android gave custom holders SparseArrays and ArrayMap to utilize instead of traditional compartments like HashMap.These compartments are configuration particularly to battle Autoboxing issue and take out both runtime overhead and extra memory designation. These holders are more memory productive than utilizing a HashMap to outline to Objects.

The following are the illustration code to make SparseArray:

sparseArray = new SparseArray();

sparseArray.put(1, “Value1”);

sparseLongArray = new SparseLongArray();

sparseLongArray.put(1, 1L);

sparseBooleanArray = new SparseBooleanArray();

sparseBooleanArray.put(1, genuine);

sparseIntArray = new SparseIntArray();

sparseIntArray.put(1, 2);

Along these lines you make your code more streamlined and memory proficient. To comprehend SparseArray and ArrayMap allude my itemized post.

How to follow memory issues?

Android Studio gives profiling apparatuses to records and figure memory distributions of your Android application. Distribution Tracker are such an intense instruments which indicates question portion and their size. It is additionally used to track memory spills.

Another great apparatus is Traceview, which is a graphical watcher for execution logs that you make by utilizing the Debug class to log following data in your code.

Conclusion

Presently a day’s the greater part of the android applications development  are taking care of thousands of information, so any enhancement you make could conceivably enhance the execution over our application. Little difference in Autoboxing matters a considerable measure for a versatile designer where you have exceptionally restricted memory and assets.

There are alot of many techniques which has to learn follow us on Android Training in Chandigarh.