Slatedroid info

Everything about android tablet pc [slatedroid]

Android Studio tutorial for beginners

Posted by wicked September - 1 - 2015 - Tuesday Comments Off

ASFeaturedPic

Android is a very good platform to develop on. Google has spent a lot of time and energy to make things as easy as possible. Succeeding Eclipse as the main IDE, Android Studio has come along way since its introduction in 2014. Here’s how to use it.

The Basics

ASNewProj
Android Studio replaced Eclipse as the main IDE for Android development in 2014. With this change Google has revamped the way developers can take advantage of all the Android development tools.

One of these improvements is the way setting up a new project works. It has never been easier to set up a new project, just click File>New>New Project and Android Studio will step you through exactly what you need to get started. Once this step is completed, click on File>New Module to create the actual Graphical User Interface of the app. This creates a new Module with a few folders and other files. Starting with the “manifests” folder which holds the AndroidManifest.xml. The file holds basic information including the name of the app that shows up on the device and any permissions that you define. Here is a sample AndroidManifest.xml:

AndroidManifest

This is the AndroidManifest.xml that Google provides when you make a new module. The java folder hosts the java classes needed to make the app work, these can get very complex depending on what you want to accomplish. The “Hello World!” application only has 37 lines of code. Under the “res” folder you will find any images that are needed as well as icons and the layout XMLs. The “activity_main.xml” controls the content and design of the main activity.

Android Studio has a user interface that allows you to dragged and dropped different UI items into place on the activity, or if you prefer you can add the items straight in the code. Under the “values” folder there is the ability to change themes for the activity, the default is “android:Theme.Holo.Light.DarkActionBar” which provides a white background and a gray action bar.

What is Gradle?

Gradle is a build automation tool that sets out to be easier than traditional XML based project configurators and was made for large projects. One benefit is that it knows what parts of the build-tree are up to date, so those parts do not have to be re-executed. Gradle is written in Java and Groovy, which makes it relatively easy to do the basic things needed for an application. Gradle was introduced in 2007, but has only been used for Android since the release of Android Studio.  Note that each module in a project will have its own Gradle file. Gradle provides an easy way to configure app details including build version and SDK version. A Gradle file will look something like this:
Gradle
Just like the Android Manifest, this can get more complicated, especially if dealing with an Android Wear module as well as a phone module. In a Gradle file you can configure the SDK versions needed for your app, the app version and the ProGuard options. ProGuard has a lot of benefits including the ability to obfuscate and shrink the code in the application, making the overall footprint smaller, more efficient, and harder to reverse engineer. However, ProGuard is not compatible with every app. In my experience developing for Android Wear, ProGuard will not work if the watch is pulling the weather from the phone. This may just be on my end but I haven’t found a workaround to get ProGuard to work.

The Android SDK, AVD Manager and ADM

SDK Manager
The Android SDK includes all the necessary libraries and files for Android Developers to get started. What is nice about Android Studio is that the SDK is built right in and is easy to access by just clicking a button on the top toolbar. The items beside the SDK Manager icon include the Android Virtual Device Manager and Android Device Monitor. The AVD Manager allows you to set up Android virtual devices to test apps on. You can configure just about anything from the device size to the instruction set architecture. If you select an Intel x86_64 instruction set architecture you can run the AVD in something known as “fast virt mode”, this uses Intel’s Hardware Accelerated Execution Manager (HAXM) which allows for a very smooth experience when running an AVD. The Android Device Monitor allows the user to monitor everything that is happening on the device at any given time, it acts like a turbocharged LogCat with a graphical user interface essentially, this makes it very easy to debug apps and see what outside sources may be conflicting.

How to run an application in Android Studio

With the tools mentioned above it is extremely easy to run and manage applications. To run an application just click the green arrow in the taskbar, this will run Gradle to make sure there are no errors then pull up the device menu. From here you can select what device you want the app to run on, whether it be an AVD or a physical device. Projects with one module will default to that module, but a module will have to be chosen when there are more than one. An extra dialog box will pop up and let the user choose a module they want to run. When the app is running you can check the LogCat or ADM to make sure everything is running right.

How to compile and export a signed APK

Once the application performs like it should the next step is to export it. This is a fairly simple process. Click Build>Generate Signed APK… and a box will pop up, select the correct module then create a new keystore. A keystore is a binary certificate that is needed when making a release build. It is recommended to work with debug versions of the app until the app is ready for release. The option to change to a release build is in the project’s manifest by adding and setting “android:debuggable” to “false” or by just selected “release” in the dialog box when generating the signed APK. Once finish is clicked Android Studio will generate a signed APK file to the destination specified, this APK can be used like any normal APK by just installing it on a device or can be used to put an application on the Google Play Store. The APK must be signed and must have been generated as a release build to upload to the Play Store. Note: If the application is an Android Wear app, the phone module will need to be exported, not the watch module, with a few lines added to the Gradle file the wear module will be included in the application with the mobile module.

Wrap-up

Android Studio makes life a lot easier when developing for Android. With tools like the Android Virtual Device Manager and Android Device Monitor it has never been easier to make sure the application runs just right in any scenario. Gradle makes it easy to configure the application details without being overly complicated as well as making sure there are no errors in the code. Android development has never been more easy and fun, with just a few steps and a little work anything is possible. Here is the link to grab Android Studio.

Sony adds binaries for 64-bit devices

Posted by wicked August - 17 - 2015 - Monday Comments Off

Sony_Xperia_Z3v_Front_Lower_Sony_Logo_TA

Sony has uploaded a new set of operating system binaries for their first 64-bit devices based on Android 5.1 Lollipop. The new files will work on the Sony Xperia Z3+, Xperia Z4 Tablet and the Xperia Z4 Tablet WiFi. All of these devices are based on the Qualcomm Snapdragon 810 processor. With these files uploaded to the Sony AOSP for Xperia web site, the custom ROM community will be able to more easily produce customized, AOSP based ROMs.

Along with those devices, Sony also created a new file repository for the Xperia M4 Aqua even though the device is not able to be unlocked at present. The Xperia M4 Aqua is based on the mid-range Snapdragon 615 chip from Qualcomm.

Developers interested in pulling these AOSP builds into their ROM creations can head over to Sony’s site to download the binaries and instructions. Sony does say there may be a few stability issues and functions disabled.

source: Sony
via: Android Authority

Come comment on this article: Sony adds binaries for 64-bit devices

Vulkan API promises significant graphical improvements for Android gaming and 3D graphics

Posted by wicked August - 10 - 2015 - Monday Comments Off

vulkan gnomes3D graphics have been moving very quickly in the mobile space, getting increasingly competitive with traditional home video game consoles and the like. That trend will continue now that Vulkan, a 3D rendering API, is coming to Android to improve the graphics experience on mobile devices.

Vulkan is a much more efficient API than Open GL ES that Android currently uses, offering a significantly lower CPU overhead and better tools for developers. A video showcasing a horde of gnomes was created to really show off the difference between the two APIs, and it’s incredibly apparent how much better Vulkan should be for mobile gaming. 

The video shows tons and tons of gnomes on screen, and while both video stay pretty close in FPS at first, once the camera starts panning around and scrolling, Open GL fails to keep a decent framerate. On top of that, not only does Vulkan offer a drastically smoother experience, but CPU usage is much lower, too. That gives more room for game developers to squeeze some extra processing power out of an app, but it also means that energy consumption should be vastly improved.

The Vulkan API isn’t publicly available just yet, but once it is we should start to see some pretty quick improvements on gaming on Android devices, including things like Android TV consoles. Something like Razer’s Forge TV and NVIDIA’s Shield TV stand to gain the most from a more efficient API, since they’re competing more directly with home consoles like the PlayStation 4 and Xbox One.

source: Android Developers Blog

Click here to view the embedded video.

Come comment on this article: Vulkan API promises significant graphical improvements for Android gaming and 3D graphics

Using shared element transitions in activities and fragments

Posted by wicked August - 7 - 2015 - Friday Comments Off

Android code programming

Historically, transitions between activities and fragments in Android involved animating the entire view hierarchy. However, with Material Design, it is now easier to animate selected Views during a transition to emphasize continuity, and guide users to content in the target Activity/Fragment.

Many times, there are similar widgets between the start and target activities, and shared element transitions, when used effectively, blurs the boundary between both activities, and the switch between both activities becomes less jarring, and feels natural and unforced. Shared element transitions can be used to guide the user to new content, and its position in the new Activity.

Before we begin, note that shared element transitions discussed here require Android 5.0 (API 21) and above, even using the Support libraries. As such, the code is littered with checks for the build version. In addition, while similar, shared element transitions are different for activities and fragments, and so, we will discuss them separately.

Shared elements in Activities

In the sample project, available on github, we implement two activities, StartActivity and EndActivity.
The StartActivity has an ImageView, a Button and a TextView saved in res/layout/activity_start.xml.

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:layout_margin="16dp">

    <ImageView
        android:id="@+id/imageView"
        android:layout_width="120dp"
        android:layout_height="120dp"
        android:layout_centerHorizontal="true"
        android:src="@drawable/aa_logo_green"
        android:transitionName="@string/activity_image_trans"/>

    <TextView
        android:id="@+id/textView"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_below="@id/imageView"
        android:text="Simple TextView"
        android:textSize="20sp"/>

    <Button
        android:id="@+id/button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@id/textView"
        android:layout_alignParentEnd="true"
        android:layout_alignParentRight="true"
        android:text="Click Me"
        style="@style/Widget.AppCompat.Button.Borderless"
        android:onClick="onClick"/>

</RelativeLayout>

The EndActivity has two ImageViews and an EditText, and is saved in res/layout/activity_end.xml.

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:layout_margin="16dp">

    <ImageView
        android:id="@+id/imageView"
        android:layout_width="220dp"
        android:layout_height="220dp"
        android:layout_alignParentEnd="true"
        android:layout_alignParentRight="true"
        android:layout_alignParentBottom="true"
        android:src="@drawable/aa_logo_green"
        android:transitionName="@string/activity_image_trans"/>

    <EditText
        android:id="@+id/editText"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_alignParentStart="true"
        android:layout_alignParentLeft="true"
        android:hint="An EditText"
        android:textSize="24sp"/>

    <ImageView
        android:id="@+id/smallerImageView"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_toLeftOf="@id/imageView"
        android:layout_alignBottom="@id/imageView"
        android:layout_alignParentStart="true"
        android:layout_alignParentLeft="true"
        android:src="@drawable/aa_logo_blue"/>

</RelativeLayout>

Take note of the transitionName attribute in both the StartActivity and EndActivity. This attribute is used to guide track shared elements between both activites. Shared elements do not need to have the same id, and do not even have to be of the same widget type. As will be shown subsequently, you can have a shared element transition from one type of View to virtually any other.

As long as you have defined the same transitionName for both Views, performing a shared element transition becomes pretty straightforward. In StartActivity,

    public void onClick(View view) {
        Intent intent = new Intent(this, EndActivity.class);
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            ActivityOptionsCompat options = ActivityOptionsCompat.
                    makeSceneTransitionAnimation(this, imageView, getString(R.string.activity_image_trans));
            startActivity(intent, options.toBundle());
        }
        else {
            startActivity(intent);
        }
    }

We called ActivityOptionsCompat.makeSceneTransitionAnimation(), since we extend the AppCompatActivity for our Activity classes. The method expects the start activity, the View to transition to the target activity, and the shared element transitionName. (NOTE: If you are not using the Support Libraries, then you would use ActivityOptions rather than ActivityOptionsCompat).

aa_shared_activity_single

However, it is highly likely that your app contains some dynamically generated content, such that setting the transitionName in xml becomes not feasible. Not to worry, the transitionName can be set in code, in both the start and end activities respectively, and the transition will still get executed.

Think about the process flow. Before the transition begins, the target activity’s layout must be known. Hence, the onCreate() method of the target activity must have been called, and the correct view inflated. Therefore, in the onCreate() method, we can identify the target views and set the transitionName.

The code snippet below uses three shared elements, with two of them set dynamically.

    public void onClick(View view) {
        View imageView = findViewById(R.id.imageView);
        View textView = findViewById(R.id.textView);
        View button = findViewById(R.id.button);
        if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            textView.setTransitionName(getString(R.string.activity_text_trans));
            button.setTransitionName(getString(R.string.activity_mixed_trans));

            Intent intent = new Intent(this, EndActivity.class);
            Pair<View, String> pair1 = Pair.create(imageView, imageView.getTransitionName());
            Pair<View, String> pair2 = Pair.create(textView, textView.getTransitionName());
            Pair<View, String> pair3 = Pair.create(button, button.getTransitionName());
            ActivityOptionsCompat options = ActivityOptionsCompat.
                    makeSceneTransitionAnimation(this, pair1, pair2, pair3);
            startActivity(intent, options.toBundle());
        }
        else {
            startActivity(intent);
        }
    }

We create Pair objects, containing the desired beginning View, and the transitionName for that View. The makeSceneTransitionAnimation() method we use here expects an activity, followed by a list of Pair objects, containing all desired shared transition Views. (Recall that we are using the support library, so we import the android.support.v4.util.Pair class, rather than android.util.Pair)

In EndActivity, we find the two target views that need transitionNames to be set dynamically. The TextView, from StartActivity, transitions into an ImageView, while the Button transitions into an EditText.

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_end);

        View smallImageView = findViewById(R.id.smallerImageView);
        View editText = findViewById(R.id.editText);
        if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            smallImageView.setTransitionName(getString(R.string.activity_text_trans));
            editText.setTransitionName(getString(R.string.activity_mixed_trans));
        }
    }

aa_shared_activity_all

Be careful with shared element transitions. You do not want too many shared elements, which can become distracting and confusing rather than smooth and natural. You want to direct user focus in a non obtrusive manner.

Shared Elements with Fragments

Shared element transitions with Fragments works in an idealistically similar way to Activities shown above. We implement two Fragments, StartFragment and EndFragment.

StartFragment contains a single ImageView, and a ListView. The ImageView has a transitionName attribute set, to guide a static transition.

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <ImageView
        android:id="@+id/imageView"
        android:layout_width="wrap_content"
        android:layout_height="80dp"
        android:src="@drawable/nav_image"
        android:transitionName="@string/fragment_image_trans"/>

    <ListView
        android:id="@+id/listView"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_below="@id/imageView">

    </ListView>
</RelativeLayout>

The EndFragment contains two ImageViews and a single TextView. One of the ImageViews has its transitionName attribute set.

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:padding="24dp"
    android:orientation="vertical">

    <ImageView
        android:id="@+id/listImage"
        android:layout_width="120dp"
        android:layout_height="120dp"
        android:layout_alignParentEnd="true"
        android:layout_alignParentRight="true"
        android:src="@drawable/aa_logo_blue"/>

    <TextView
        android:id="@+id/smallerImageView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerVertical="true"
        android:layout_alignParentEnd="true"
        android:layout_alignParentRight="true"
        android:text="Sample"
        android:textSize="24sp"/>

    <ImageView
        android:id="@+id/otherImage"
        android:layout_width="120dp"
        android:layout_height="120dp"
        android:layout_alignParentBottom="true"
        android:layout_alignParentEnd="true"
        android:layout_alignParentRight="true"
        android:layout_marginTop="24dp"
        android:src="@drawable/nav_image"
        android:transitionName="@string/fragment_image_trans"/>
</RelativeLayout>

Shared element transitions between activities has a sane default transition, that works pretty much as expected. For fragments, however, you have to specify a Transition. We define a transition set in res/transition, called change_image_trans. The transition set contains two transition types, changeTransform and changeBounds. changeTransform captures scale and rotation for Views before and after the scene change, while changeBounds captures the layout bounds of target views before and after the scene change. Both transition types also handle the animation of the changes between both target Views. As a result, we can be certain our Views would scale up or down in size as necessary, in addition to starting and ending at the correct location on screen.

<?xml version="1.0" encoding="utf-8"?>
<transitionSet xmlns:android="http://schemas.android.com/apk/res/android">
    <changeTransform />
    <changeBounds />
</transitionSet>

To animate the transition in a FragmentTransaction, we call setSharedElementEnterTransition() and setEnterTransition() on the target fragment (EndFragment). We also call setSharedElementReturnTransaction() and setExitTransition() on the start fragment (StartFragment).
Finally, while building the FragmentTransaction, we call addSharedElement(), containing the initial View, and the transitionName.

    @Override
    public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
        ImageView staticImage = (ImageView) getView().findViewById(R.id.imageView);

        EndFragment endFragment = new EndFragment();

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            setSharedElementReturnTransition(TransitionInflater.from(
                    getActivity()).inflateTransition(R.transition.change_image_trans));
            setExitTransition(TransitionInflater.from(
                    getActivity()).inflateTransition(android.R.transition.fade));

            endFragment.setSharedElementEnterTransition(TransitionInflater.from(
                    getActivity()).inflateTransition(R.transition.change_image_trans));
            endFragment.setEnterTransition(TransitionInflater.from(
                    getActivity()).inflateTransition(android.R.transition.fade));
        }

        Bundle bundle = new Bundle();
        bundle.putString("ACTION", textView.getText().toString());
        bundle.putParcelable("IMAGE", ((BitmapDrawable) imageView.getDrawable()).getBitmap());
        endFragment.setArguments(bundle);
        FragmentManager fragmentManager = getFragmentManager();
        fragmentManager.beginTransaction()
                .replace(R.id.container, endFragment)
                .addToBackStack("Payment")
                .addSharedElement(staticImage, getString(R.string.fragment_image_trans))
                .commit();
    }

aa_shared_fragment_single

To implement multiple shared elements as well as dynamically generated shared elements, we use a ListView, with list items containing an ImageView and a TextView. In the ListAdapter, we set a transitionName for both the ImageView and the TextView for every list item.

class MyListAdapter extends ArrayAdapter<String> {

    @Override
    public View getView(int position, View convertView, ViewGroup parent) {

        View view = convertView;

        if (view == null) {
            view = LayoutInflater.from(getContext()).inflate(R.layout.list_item, null);
        }

        TextView textView = (TextView) view.findViewById(R.id.textView);

        ImageView imageView = (ImageView) view.findViewById(R.id.imageView);

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            textView.setTransitionName("transtext" + position);
            imageView.setTransitionName("transition" + position);
        }

        return view;
    }
}

Setting up the transition is similar to the single element transition. The main difference here is we fetch the two dynamically generated transition names, and wrap them in a bundle for the target fragment. Finally, for each shared element, we call the addSharedElement() method.

    @Override
    public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
        String imageTransitionName = "";
        String textTransitionName = "";

        ImageView imageView = (ImageView) view.findViewById(R.id.imageView);
        TextView textView = (TextView) view.findViewById(R.id.smallerImageView);

        ...
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            ...
            imageTransitionName = imageView.getTransitionName();
            textTransitionName = textView.getTransitionName();
        }

        bundle.putString("TRANS_NAME", imageTransitionName);
        bundle.putString("TRANS_TEXT", textTransitionName);
        endFragment.setArguments(bundle);
        ...
        fragmentManager.beginTransaction()
                .replace(R.id.container, endFragment)
                .addToBackStack("Payment")
                .addSharedElement(imageView, imageTransitionName)
                .addSharedElement(textView, textTransitionName)
                .addSharedElement(staticImage, getString(R.string.fragment_image_trans))
                .commit();
    }

In EndFragment, we retrieve the transition names, and update the target Views.

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        Bundle bundle = getArguments();
        String actionTitle = "";
        Bitmap imageBitmap = null;
        String transText = "";
        String transitionName = "";

        if (bundle != null) {
            transitionName = bundle.getString("TRANS_NAME");
            actionTitle = bundle.getString("ACTION");
            imageBitmap = bundle.getParcelable("IMAGE");
            transText = bundle.getString("TRANS_TEXT");
        }

        getActivity().setTitle(actionTitle);
        View view = inflater.inflate(R.layout.fragment_end, container, false);

        if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            view.findViewById(R.id.listImage).setTransitionName(transitionName);
            view.findViewById(R.id.smallerImageView).setTransitionName(transText);
        }

        ((ImageView) view.findViewById(R.id.listImage)).setImageBitmap(imageBitmap);
        ((TextView) view.findViewById(R.id.smallerImageView)).setText(actionTitle);

        return view;
    }

aa_shared_fragment_all

Wrap-up

Well planned transitions and animations provides an app with a premium feel, and will be pleasurable for users. Movements between activities and fragments will appear to flow naturally, and will also guide a user’s focus towards the relationship between the new screen and the previous screen. The complete source code for the tutorial is available on GitHub, and can be used and modified to your heart’s content. Happy coding.

Chris Lacy’s Link Bubble gets an update to v1.5 along with a change of ownership

Posted by wicked August - 5 - 2015 - Wednesday Comments Off

LinkBubble

Link Bubble users will be happy to note that the app has received a substantial update to version 1.5, with features such as drop down elements, domain redirects as well as a Material Design overhaul making an appearance. Link Bubble’s creator, Chris Lacy, has also taken the opportunity to announce that Link Bubble and another of his apps, Tap Path, along with all related assets, have been sold to an as yet unnamed buyer. Join us after the break for the update’s changelog as well as more information on the change in ownership.

Let’s deal with the changes brought about in Link Bubble version 1.5.

Changelog:

  • Support for drop down elements
  • Added ability to colour the toolbar with a website’s theme/ favicon colour (Settings/ Colour Toolbar)
  • Added ‘Domain redirects’ customization, allowing you to define domains which, when loaded, will always be referred to your fallback browser
  • Updated appearance for material design
  • Use Lollipop themed Snackbar prompt
  • Translation support for 6 new languages

Regarding the change in ownership, if you have previously purchased Link Bubble Pro or Tap Path, those purchases are still connected to your Google Account, and you will receive updates via the Play Store as normal. Chris Lacy states that the transition will be ‘entirely seamless‘. As for the mysterious entity that purchased Link Bubble and Tap Path, Lacy says that the new owner is a US startup that is currently in ‘Stealth mode‘, but that users should trust him when he says it will become obvious why he is so excited by both the sale of the apps and their future.

For those asking why Chris Lacy sold the apps, he says that his indie company just doesn’t have the resources to make the most of Link Bubble’s potential. Which is fair enough.

You can download the floating browser app, Link Bubble, either by scanning the QR code or by clicking on the Play Store link below.

 

qr codeGoogle Play Store Get it Here

Source: Chris Lacy (Blog)

Come comment on this article: Chris Lacy’s Link Bubble gets an update to v1.5 along with a change of ownership

Screenshot_2015-07-19-11-25-47

Spicing up your homescreen to your liking has always been one of Androids selling points. The sky, along with your imagination, is always the limit when it comes to decorating your Android device. Thankfully, we have plenty of talented and artistic developers out there that create beautiful widgets and skins for our devices. A new Zooper Widget theme that I recently stumbled upon certainly has that creative style that I think you all can appreciate. The app is called Zoopreme and is available on the Google Play Store for $1. If you’re already familiar with Zooper Widget Pro, then this will be very easy to apply.

As you can see by the various screenshots, Zoopreme adds color and style to your homescreen. Of course, a nifty wallpaper and custom icons are needed to completely these looks. You may even be able to find a lot of these wallpapers on the developers (Erik Blue’s) Google+ page that I will link right here.

BabyHulk
15 - 1
15 - 2
15 - 1 (3)

If you guys decide to nab this app, let me know what you think! Do you guys have any favorite Zooper Widget themes that you use? If so, let me know in the comments section! Links and a QR code will be available below.

 qr code
Play Store Download Link

Come comment on this article: Looking for something new to spice up your home screen? Check out Zoopreme Widgets by Erik Blue

18.1% of Android devices are now running Lollipop

Posted by wicked August - 3 - 2015 - Monday Comments Off

sony_lollipop_red_headerGoogle usually list the Android distribution numbers, but decided to skip July’s. However, now it’s August and Google has updated them again. Lollipop is now installed on 18.1% of Android devices which is up from 12.4% in June.

KitKat has also moved up a little from 39.2% to 39.3%. Jelly Bean on the other hand has declined from 37.4% to now 33.6%.

Of course we can’t forget about the much older versions of Android. Ice Cream Sandwich is at 4.1% while Gingerbread has move down to 4.6% from 5.6%. Finally, aging Froyo is still installed on 0.3% of devices.

android-version-numbers-august2015

Source: Google

Come comment on this article: 18.1% of Android devices are now running Lollipop

Using the Android Percent Support Library

Posted by wicked August - 3 - 2015 - Monday Comments Off

android developer development Alper Çuğun

Android’s standard layouts can be confusing. When one attribute interacts with another attribute, you can get some surprising results. So it helps to have attributes with intuitive meanings, such as layout_widthPercent in the new Percent Support Library.

To test this new android.support.percent package, I created my own sample project. As usual, Android Studio created the default build.gradle and activity_mail.xml files. I tweaked the build.gradle file a tiny bit:

apply plugin: 'com.android.application'

android {

  compileSdkVersion 21

  buildToolsVersion "22.0.0"

  defaultConfig {

    applicationId "com.allmycode.percentlayout"

    minSdkVersion 16

    targetSdkVersion 21

    versionCode 1

    versionName "1.0"

  }

  buildTypes {

    release {

      minifyEnabled false

      proguardFiles getDefaultProguardFile \

        ('proguard-android.txt'), 'proguard-rules.pro'

    }

  }

}

dependencies {

  compile fileTree(dir: 'libs', include: ['*.jar'])

  compile 'com.android.support:percent:22.2.0'

}

In the build.gradle file, I changed the minimum SDK version to 16. More importantly, I added the line

compile 'com.android.support:percent:22.2.0'

to the file’s dependencies section. (Later, when I tried running the project, Android Studio noticed that I didn’t have this support:percent library on my local machine. Android Studio had no trouble locating the library for download and installing it automatically.)

Before editing the layout file’s XML code, I dropped three buttons from the Palette in Android Studio’s Designer Tool.

The Percent Support Library has two pre-built layouts – the PercentRelativeLayout and the PercentFrameLayout. To try out the PercentRelativeLayout, I edited some of the activity_main.xml file’s text:

<android.support.percent.PercentRelativeLayout

  xmlns:android="http://schemas.android.com/apk/res/android"

  xmlns:app="http://schemas.android.com/apk/res-auto"

  xmlns:tools="http://schemas.android.com/tools"

  android:layout_width="match_parent"

  android:layout_height="match_parent"

  android:paddingBottom="@dimen/activity_vertical_margin"

  android:paddingLeft="@dimen/activity_horizontal_margin"

  android:paddingRight="@dimen/activity_horizontal_margin"

  android:paddingTop="@dimen/activity_vertical_margin"

  tools:context=".MainActivity">

                 
  <Button

    android:id="@+id/button"

    android:text="Button"

    android:layout_height="wrap_content"

    android:layout_alignParentTop="true"

    app:layout_widthPercent="30%"/>

         
  <Button    

    android:id="@+id/button2"

    android:text="Button 2"

    android:layout_height="wrap_content"

    android:layout_toRightOf="@id/button"

    app:layout_widthPercent="60%"/>

  <Button

    android:id="@+id/button3"

    android:text="Button 3"

    android:layout_height="wrap_content"

    android:layout_below="@+id/button"

    android:layout_alignParentStart="true"

    android:layout_alignParentLeft="true"

    app:layout_widthPercent="90%"/>

</android.support.percent.PercentRelativeLayout>

In the activity_main.xml file, I typed only a few lines manually. Most importantly, I added three app:layout_widthPercent attributes. (The PercentRelativeLayout also has layout_heightPercent, layout_marginPercent, and other percentage-related attributes, but I used only layout_widthPercent in this first experiment.)

The new PercentRelativeLayout class extends Android’s existing RelativeLayout class. So, to specify the relative positions of things, I used familiar attributes like layout_toRightOf and layout_alignParentStart. I also mixed percentage sizes with the existing RelativeLayout sizes. In my example’s layout file, I specified android:layout_height=”wrap_content” for all three buttons.

Notice that, in each of the layout file’s <Button> elements, I didn’t bother specifying an android:layout_width attribute. That’s good because a layout_width attribute (even one that’s ignored by the runtime) would be redundant and confusing next to its layout_widthPercent cousin. Android Studio isn’t used to the lack of this layout_width attribute, so I saw an error marker on each <Button> element in the editor. But I ignored this error marker, and the code ran correctly.

Here’s my sample layout, running on a ZenFone 2 with Android 5.0:

1

And here’s the same layout with the phone in landscape mode:

2

The layout adjusts nicely (and very naturally) to changes in the device’s orientation.

Of course, the Percent Support Library isn’t a silver bullet. This support library doesn’t eliminate interactions among attributes, and developers must be careful to test layouts before deploying them in the wild.

Here’s an example: I added a layout_centerHorizontal attribute to the first button in my layout:

<Button

    android:id="@+id/button"

    android:text="Button"

    android:layout_height="wrap_content"

    android:layout_alignParentTop="true"

    android:layout_centerHorizontal="true"

    app:layout_widthPercent="30%"/>
              

  <Button

    android:id="@+id/button2"

    android:text="Button 2"

    android:layout_height="wrap_content"

    android:layout_toRightOf="@id/button"

    app:layout_widthPercent="60%"/>

When I did this, there wasn’t room to the right of the first button for a second button of width 60 percent, so Android ignored the second button’s layout_widthPercent=”60%” attribute:

3

As an author, I’m excited about the new Percent layouts. I can spare my readers paragraphs of explanation about weights and other features by simply referring to the intuitive notion of percentage sizes.

Making an app with no programming experience: what are your options?

Posted by wicked July - 31 - 2015 - Friday Comments Off

Meizu MX5-18

Android app development has grown exponentially since the Google Play store was launched in 2008 as Android Market. Today, there are estimated to be over 1.6 million apps on the Play Store, and 1.4 million apps on the iOS App Store, with a combined total download exceeding 200 billion. For more statistics, check out our Play Store vs App Store comparison. It has become increasingly easier to develop and deploy apps to both major markets, while there are also quite a few alternative mobile app market places including Amazon, Weibo and Windows Phone.

Why build an app

There are loads of reasons why an individual or company might want to build an app. For an individual, you could have an idea for app functionality and features, that nothing currently on the market caters to. Companies might want to use an app for internal tasks and communications.

Making, and releasing a mobile app is a very rewarding and fulfilling experience. And if the exhilaration isn’t enough motivation, you can monetize and make money from your app, either through ads, in app purchases or app sales.

Gone are the days when to make an app, you had to learn how to program first. Of course, as a developer myself, I would encourage budding app-preneurs to learn how to code, especially if you hope to develop a completely new app, or enter (and disrupt) an existing industry. However, not all types of apps are new, unique and/or disruptive. Many apps will be built to handle the same kinds of use cases, only with custom content. For these kinds of apps, learning to code might not be the most efficient use of your time and money.

If you intend to make an app with no programming experience, the options available to you include:

Contract a company

Depending on your budget constraints (or lack of), getting a professional app development company might be your best bet. Most app development companies can also provide apps for multiple platforms, and will usually work with the client through planning, execution and deployment of the app. Additionally, the company can also handle maintenance and upgrades if necessary.

Hire a freelancer

There are a ton of websites on which you can meet and hire a freelance app developer. A (non-exhaustive) list of freelance sites includes

Hiring a good freelancer is pretty much a matter of luck. Your mileage here may vary, and clients have reported bids on the same project varying in range from $22 to $10,000! Most freelance websites have a ratings system, and you can then judge a potential hire by his acquired ratings. However, using the ratings system is skewed towards long time users, resulting in new users bidding really low to be competitive. Some websites aim to streamline the process of finding good freelancers, by having a more involved vetting process. They usually have higher quality developers, but almost certainly cost more as a result.

Use an app building platform

When it comes down to it, a large number of mobile apps have identical features and functionality, especially apps for a business or website. For example, if you run a restaurant business, and want to build an app for users to make orders. You can make do with a well designed generic app, that has your business’s logos, colors and menu. Some great app building platforms that have caught our eye include


Andromo

aa-appmaker-andromo Andromo bills itself as a “point and click” Android app making platform. With Andromo, you can include maps, photo galleries, blog and news feeds, youtube videos, twitter and facebook feeds among others. In addition, you can choose to embed ads within your app to make money. You can try it for free, before deciding to shell out cash for the service.


Appery.io

aa-appmaker-apperyAppery is a platform that can be used to develop hybrid apps targeting Android, iOS and Windows Phone devices. Appery apps can customized using HTML5, Javascript and CSS to build custom UI components, and or custom code. Appery can also be tried for free.


AppMakr

aa-appmaker-appmakrAppMakr appears to be the cheapest platform so far, with pricing beginning from $1 per month. With AppMakr, you can build Android, iPhone and HTML5 apps that contain image galleries, videos, podcasts, push messaging, analytics and ads. Currently, AppMakr claims to have been used to build over 2 million apps.


AppyPie

aa-appmaker-appypieAppyPie wants making apps to be as easy as pie. There are a ton of templates (or categories) to choose from, and apps can be built for Android, Blackberry, iOS, Kindle and Windows. AppyPie also includes options for analytics, monetization with ads and offers, as well as push notifications. AppyPie also has a game builder, through which you can create a HTML5 game, and build it for Android, iOS and HTML5 devices.


GameSalad

aa-appmaker-gamesaladGameSalad claims on its front page that in an hour, a total newbie can make their first game. They also, as at July 2015, claim to have over 65,000 games published, with over 80 of them making the top 100 games in the US App Store. GameSalad supports Android, Kindle, iOS, Windows and HTML5 devices. The GameSalad game creator is available for download for both Mac and Windows systems. GameSalad supports monetization with ads, and has an active community. Definitely worth checking out, if you’re looking to build a mobile game.


GoodBarber

aa-appmaker-goodbarberGoodBarber generates native mobile apps for both iOS and Android devices, as well as an HTML web app for other devices. It can also include maps, user generated content, provides traffic, social, technical stats, integrates both it’s own internal ad network as well as third party ad networks and can also include both Flurry and/or Google analytics. In addition, for a fee, GoodBarber can publish your app to the Apple App Store for you, although you must have your developer account first. GoodBarber provides a 30 day trial period.


MobileRoadie

aa-appmaker-mobileroadieMobileRoadie can be used to build apps for both iOS and Android devices, and has quite a few great features. Users can integrate video, audio and photos, news and twitter feeds, events and locations in their app. An exciting feature offered by MobileRoadie is a Fan Wall, where users of the app can chat, and post photos, with each other in real time, in threaded conversations. You can also create polls within your app. MobileRoadie has a relatively short free/trial period of 14 days.


ShoutEm

aa-appmaker-shoutemShoutEm has many of the features expected, including integrated advertising, analytics and push notifications. In addition, you can integrate WordPress, Drupal, Facebook and Twitter into your app, as well as interactive maps. If the available templates do not meet your requirements, you can contact ShoutEm for a custom look and feel.


Roundup

Much like how website design and deployment has became ubiquitous, mobile app development appears to be approaching the same fate. For apps that are not a completely new idea, there is most likely an existing template, that can be easily modified and customized. For some apps, it can be beneficial, and more economically viable, to use an app building platform. For other types of apps, especially for totally new and/or unique ideas, either a freelancer or app development company will be the smarter option. You can also find an excellent developer to partner with.

Did we miss your favorite app building platform, or do you know any other ways to make an app with no programming experience? Share your thoughts in the comments below.

New beta track options now available for Android developers

Posted by wicked July - 30 - 2015 - Thursday Comments Off

android_developers_site_heading

Starting today, there are new methods for Android developers looking to test their apps with users. Google says it will be an easier, more convenient way for developers to beta test their apps upon release.

The following are new features available to developers:

  • Open beta – Use an open beta when you want any user who has the link to be able to join your beta with just one click. One of the advantages of an open beta is that it allows you to scale to a large number of testers. However, you can also limit the maximum number of users who can join.
  • Closed beta using email addresses – If you want to restrict which users can access your beta, you have a new option: you can now set up a closed beta using lists of individual email addresses which you can add individually or upload as a .csv file. These users will be able to join your beta via a one-click opt-in link.
  • Closed beta with Google+ community or Google Group – This is the option that you’ve been using today, and you can continue to use betas with Google+ communities or Google Groups. You will also be able to move to an open beta while maintaining your existing testers.

Google went on to mention that nearly 80% of its developers are currently using the new methods of beta testing in Google Play.

Click here to view the embedded video.

Source: Android Developers Blog

Come comment on this article: New beta track options now available for Android developers

ePad 7 Android 4.0 ICS
$162 $100 FREE SHIPPING 

10" Android 4.2 1.2GHz Tablet PC

7