Welcome. Here you find latest freeware and legal software as well as latest info about IT Technology.
Showing posts sorted by relevance for query android. Sort by date Show all posts
Showing posts sorted by relevance for query android. Sort by date Show all posts
Google Android N (7.0) developer preview released, and its features out.


Android N Mobile

Surprise for developer and Android lover that Google released developer preview of upcoming android version, code named as "N". This is the first time ever that the engineering hulk broke from its custom of releasing new versions of its popular mobile operating system Explaining the rationale behind the move, Google’s SVP for Android, Chrome OS and Chromecast, Hiroshi Lockheimer, wrote on Medium, "By releasing the first preview and asking for your feedback now (in March!), we’ll be able to act on that feedback while still being able to hand off the final N release to device makers this summer, so they can get their hands on the latest version of Android earlier than ever. Plus, you’ll be able to use this additional time to support all of the new goodies in N in your apps."


Building an app just got a lot easier thanks to Google’s release of Android Studio 2.0. Following the highly successful initial launch of its official integrated development environment (IDE) back in 2013, the Internet giant has now taken things to the next level with improvements to its Android Studio. With 1.6 million apps already inundating its Play Store, it’s clear that developers are already eager to build apps for Google, but now, things are about to get faster, higher quality, and just all around better.

DOWNLOAD NOW

Top 10 Most Common Mistakes That Android Developers Make: A Programming Tutorial


BY IVAN DIMOSKI - ANDROID ENGINEER @ TOPTAL

Android. What’s not to like about this platform? It’s free, it’s customizable, it’s rapidly growing and it’s available not just on your phone or tablet, but on your smartwatch, TV and car too.
With the latest Lollipop update, Android programming continues to improve. The platform has matured quite a bit since the initial AOSP release, and set the user expectations bar quite high. Look how good the new Material design pattern looks!
There are thousands of different devices, with different screen sizes, chip architectures, hardware configurations, and software versions. Unfortunately, segmentation is the price to pay for openness, and there are thousands of ways your app can fail on different devices, even as an advanced Android programmer.
Regardless of such huge segmentation, the majority of bugs are actually introduced because of logic errors. These bugs are easily prevented, as long as we get the basics right!
Here’s an Android programming tutorial to address the 10 most common mistakes Android developers make.
Learn Android programming at a more advanced level with this tutorial.

Common Mistake #1: Developing for iOS

To my great pleasure, this Android mistake is far less common nowadays (partially because clients are beginning to realize that the days when Apple was setting all the design standards are long gone). But still, every now and then, we see an app that is an iOS clone.
Don’t get me wrong, I’m not an Android programming evangelist! I respect every platform that moves the mobile world a step forward. But, it’s 2014 and users have been using Android for quite a while now, and they’ve grown accustomed to the platform. Pushing iOS design standards to them is a terrible strategy!
Unless there is a super good reason for breaking the guidelines, don’t do it. (Google does this all the time, but never by copy-pasting.)
Here are some of the most common examples of this Android mistake:
  1. You should not be making static tabs, and they don’t belong on the bottom (I’m pointing at you Instagram).
  2. System notification icons should not have color.
  3. App icons should not be placed inside a rounded rectangle (unless that’s your actual logo ex. facebook).
  4. Splash screens are redundant beyond the initial setup/introduction. Do not use them in other scenarios.
  5. Lists should not have carets.
These are just a few of the many other small things that can ruin the user experience.

Common Mistake #2: Developing for Your Android Device

Unless you are building a kiosk/promo app for a single tablet, chances are your Android app won’t look good on every device. Here are a few Android programming tips to remember:
There are literally thousands of possible scenarios, but after a while you develop a sense for covering them all with a handful of cases.
You don’t own thousands of devices? Not a problem. The Android Emulator is super good in replicating physical devices. Even better, try out Genymotion, it’s lightning fast and comes with a lot of different popular preset devices.
Also, have you tried rotating your device? All hell can break loose…

Common Mistake #3: Not Using Intents

Intents are one of Android’s key components. It’s a way of passing data between different parts of the app or, even better, different apps on the system.
Let’s say you have a gallery app that can share a download link to some images via SMS. Which of the two options seems more logical?
Option 1:
  • Request the SEND_SMS permission.
      
    
  • Write your own code for sending SMS using the SmsManager.
  • Explain to your users why your gallery app needs access to services that can cost money, and why they have to grant this permission to use your app.
Option 2:
  • Start an SMS Intent and let an app designed for SMS do the work
      Intent sendIntent = new Intent(Intent.ACTION_VIEW);
      sendIntent.setData(Uri.parse("sms:" + telephoneNumber));
      sendIntent.putExtra("sms_body", x);
      startActivity(sendIntent);
    
In case that you have any doubts, best solution is option 2!
This approach can be applied to almost anything. Sharing content, taking pictures, recording video, picking contacts, adding events, opening links with native apps, etc.
Unless there is a good reason to make a custom implementation (ex., a camera that applies filters), always use Intents for these scenarios. It will save you a lot of programming time, and strip the AndroidManifest.xml of unnecessary permissions.

Common Mistake #4: Not Using Fragments

A while ago in Honeycomb, Android introduced the concept of fragments. Think of them as separate building blocks with their own (rather complex) life cycles that exist inside an Activity. They help a lot with optimizing for various screens, they are easily managed by their parent activity, can be reused, combined and positioned at will.
Launching a separate activity for each app screen is terribly inefficient, since the system will try to keep them in memory as long as it can. Killing one won’t free the resources used by the others.
This Android programming tutorial recommends the proper use of fragments to make your app more efficient.
Unless you want to dig deep into the Android core and read this article, advocating against fragment usage, you should use fragments whenever possible. It basically says that fragments and cursor loaders have good intended purpose, but poor implementation.

Common Mistake #5: Blocking the Main Thread

The main thread has a single purpose: keeping the user interface responsive.
Although the science behind measuring the frame rate our eyes/brain can perceive is complex and influenced by a lot of factors, a general rule is that anything below 24 fps with delay greater than 100 ms won’t be perceived as smooth.
This means that the user’s actions will have a delayed feedback, and the Android app you have programmed will stop responding. Stripping the user of his control over the app leads to frustration, frustrated users tend to give very negative feedback.
Even worse, if the main thread is blocked for a while (5 seconds for Activities, 10 for Broadcast Receivers), ANR will happen.
As you learn Android programming, you will come to know and fear this message.  Follow these Android programming tips to minimize this occurrence.
This was so common in Android 2.x, that on newer versions the system won’t let you make network calls in the main thread.
To avoid blocking the main thread, always use worker/background threads for: 1. network calls 2. bitmap loading 3. image processing 4. database querying 5. SD reading / writing

Common Mistake #6: Reinventing the Wheel

“OK, I won’t use the main thread. I’ll write my own code that communicates with my server in a background thread.”
No! Please don’t do that! Network calls, image loading, database access, JSON parsing, and social login are the most common things you do in your app. Not just yours, every app out there. There is a better way. Remember how Android has matured and grown as a platform? Here’s a quick list of examples:
  1. Use gradle as a build system.
  2. Use Retrofit / Volley for network calls.
  3. Use Picasso for image loading.
  4. Use Gson / Jackson for JSON parsing.
  5. Use common implementations for social login.
If you need something implemented, chances are it’s already written, tested and used widely. Do some basic research and read some Android programming tutorials before writing your own code.

Common Mistake #7: Not Assuming Success

Great. We have learned that there is a better way for handling long running tasks, and we are using well documented libraries for that purpose. But the user will still have to wait. It’s inevitable. Packages are not sent, processed and received instantly. There is a round trip delay, there are network failures, packages get lost, and dreams get destroyed.
But all this is measurable. Successful network calls are far more likely than unsuccessful ones. So why wait for server response before handling the successful request? It’s infinitely better to assume success and handle failure. So, when a user likes a post the like count is immediately increased, and in unlikely event that the call failed, the user is notified.
In this modern world immediate feedback is expected. People don’t like to wait. Kids don’t want to sit in a classroom obtaining knowledge that has uncertain future payoff. Apps must accommodate to the user’s psychology.

Common Mistake #8: Not Understanding Bitmaps

Users love content! Especially when the content is well formatted and looks nice. Images, for instance, are extremely nice content, mainly due to their property of conveying a thousand words per image. They also consume a lot of memory. A lot of memory!
Before an image is displayed on the screen, it has to be loaded into the memory. Since bitmaps are the most common way to do this, we’re going to provide an Android programming guide for the whole process:
Let’s say you want to display an image on your screen that you just took with your camera. The total memory needed for this is calculated with the following formula: memory_needed_in_bytes = 4 * image_width * image_height;
Why 4? Well, the most common / recommended bitmap configuration is ARGB_8888. That means that for each pixel we draw, we need to keep 8 bits (1 byte) for the alpha, the red, the greed and the blue channel in memory, in order to properly display it. There are alternatives, like the RGB_565 configuration that requires half the memory than ARGB_8888, but loses the transparency and the color precision (while maybe adding a green tint).
Let’s assume you have a brand new device with full HD screen and 12 MP camera. The picture you just took is 4000x3000 pixels large and the total memory needed to display it is: 4 bytes * 4000 * 3000 = 48 MB
48 megabytes of your RAM just for a single image!? That’s a lot!
Now let’s take the screen resolution into consideration. You are trying to show a 4000x3000 image on a screen that has 1920x1080 pixels, in worst case scenario (displaying the image full screen) you shouldn’t allocate more than 4 * 1920 * 1080 = 8.3 MB of memory.
Always follow the Android programming tips for displaying bitmaps efficiently:
  1. Measure the view you’re showing your images in.
  2. Scale / crop the large image accordingly.
  3. Show only what can be displayed.

Common Mistake #9: Using Deep View Hierarchy

Layouts have an XML presentation in Android. In order to draw content, the XML needs to be parsed, the screen needs to be measured, and all the elements need to be placed accordingly. It’s a resource- and time-consuming process that needs to be optimized.
This is how the ListView (and more recently the RecyclerView) works.
If a layout has been inflated once, the system reuses it. But still, inflating the layout must happen at some point.
Let’s say you want to make a 3x3 grid with images. One way of doing this is a vertical LinearLayout containing 3 LinearLayouts with equal weight, each of them containing 3 ImageViews with equal weight.
Some Android programming beginners don’t always make the best use of LinearLayouts.
What do we get with this approach? A warning that “nested weights are bad for performance”.
There is a saying in the Android programming world, that I just made up: “With little effort all hierarchy can be flattened”.
In this case RelativeLayout or GridLayout will efficiently replace the nested LinearLayouts.

Common Mistake #10: Not Setting the minSdkVersion to 14

Well, this is not a mistake, but it is bad practice.
Android 2.x was a huge milestone in developing this platform, but some things should be left behind. Supporting older devices adds more complexity for code maintenance and limits the development process.
The numbers are clear, the users have moved on, the developers shouldn’t stay behind.
I’m aware that this doesn’t apply for some big markets with old devices (ex. India), and setting the minSdkVersion to 14, on the Facebook App, means leaving couple of million users without their favorite social network. But, if you are starting fresh and trying to create a beautiful experience for your users, do consider eliminating the past. Users that don’t have the resources, or feel the need to upgrade their device/OS, won’t have the incentive to try out a superior version of your Android app and ultimately spend money on it.

Wrap Up

Android is a powerful platform that evolves quickly. It may not be reasonable to expect users to keep up the pace, but it’s crucial for the Android developers to do so.
Knowing that Android is not just on our phones or tablets is even more important. It’s on our wrists, in our living rooms, in our kitchens, and in our automobiles. Getting the basics right is of utmost importance before we start expanding.

Google Android N internally known as New York Cheesecake and may be next version will named on Indian sweet.

Google rolled out new Android Developer version earlier than expected. Yes, we are talking about the version name for Android N and it now seems that Google’s team is referring it to as ‘New York Cheesecake’ internally.
Previously, Android KitKat was tagged as Key Lime Pie (klp) and the same goes for Lollipop (Lemon Meringue Pie) and the current Marshmallow (Macadamia Nut Cookie). 

So for now, New York Cheesecake only seems like an option as Google still has an online poll running asking users to decide what the next version of Android will be called. 

Android 7.0 for Developers: New Features, Performance Upgrades & Other Stuff You Won’t Care About

BY NERMIN HAJDARBEGOVIC - TECHNICAL EDITOR @ TOPTAL

Google formally announced Android 7.0 Nougat a few weeks ago, but as usual, you’ll have to wait. Most users won’t get their over-the-air (OTA) updates until early next year. Many others will receive them a week from never, as some device vendors simply don’t bother.

This may sound like a snarky pet peeve of mine, but Android fragmentation is no joke; it’s been a serious headache for users and developers for years. Android 7.0 won’t solve that issue, which is a shame because it enables a number of new features and performance improvements that users would surely enjoy.

Developers shouldn’t get their hopes up, however; there aren’t any game-changers here. Let’s look at the key tweaks under Android’s hood and the new opportunities they present, from most to least impactful.


  1. New JIT compiler, complementing ART’s existing AOT compiler
  2. Multi-window support
  3. Support for Vulkan API
  4. Direct boot
  5. Direct reply and bundled notifications
  6. Daydream virtual reality (VR) mode
  7. UI, accessibility tweaks, and background optimization

This is obviously not a comprehensive list of all new features; I settled on the top seven. You can get an in-depth overview of Android 7.0 if you head over to Google’s developer paradise. I will spare you the unnecessary fluff and provide you with useful info in a condensed, easy-to-digest form.

Google launched  Android Auto an in-car operating system in India along with 17 other countries. Car ma With a screen in the car that runs Android Auto, drivers can control music, make or receive calls, navigate and respond to messages without having to take the phone out.
Android Auto


After over a year of its global launch, Android Auto was finally introduced in India, along with 17 other countries, on Tuesday. This smartphone integration tool allows the infotainment system of a car to stream music, relay messages and calls and provide directions.

In a perfect Android world, the main language of Java is really modern, clear, and elegant. You can write less by doing more, and whenever a new feature appears, developers can use it just by increasing version in Gradle. Then while creating a very nice app, it appears fully testable, extensible, and maintainable. Our activities are not too large and complicated, we can change data sources from database to web without tons of differences, and so on. Sounds great, right? Unfortunately, the Android world isn’t this ideal. Google is still striving for perfection, but we all know that ideal worlds don’t exist. Thus, we have to help ourselves in that great journey in the Android world.

Kotlin and Java - Android
Kotlin is a popular new player in the Android world. But can it ever replace Java?
What Is Kotlin, and Why Should You Use It?
So, the first language. I think that Java isn’t the master of elegance or clarity, and it is neither modern nor expressive (and I’m guessing you agree). The disadvantage is that below Android N, we are still limited to Java 6 (including some small parts of Java 7). Developers can also attach RetroLambda to use lambda expressions in their code, which is very useful while using RxJava. Above Android N, we can use some of Java 8’s new functionalities, but it’s still that old, heavy Java. Very often I hear Android developers say “I wish Android supported a nicer language, like iOS does with Swift”. And what if I told you that you can use a very nice, simple language, with null safety, lambdas, and many other nice new features? Welcome to Kotlin.

Download Android Marshmallow 6.0 for Xiaomi Mi 4, Mi 3, Mi Note with MIUI framework.
MIUI Android Marshmallow 6
Based on Android Marshmallow 6.0, MIUI Global beta Rom 6.3.17 released today. Users of Xiaomi Mi 4, Xiaomi Mi 3, Xiaomi Mi Note will able to upgrade their device with latest rom and enjoy the best performance by their devices.
Download Fastboot Rom for Mi 3, Mi 4 (1082 MB)
Download Fastboot Rom for Mi Note (1080 MB)

Users of Xiaomi RedMi 1s can also upgrade to Marshmallow 6.0 unofficial here.
Other Mobile user see here, if there device support Android M Upgrade

How to upgrade to Android Marshmallow?

  1. If you are using MIUI global beta ROM now, go to 'Updater' app on your phone and check for updates. If you're on older versions before MIUI 5.12.17, you will firstly update to 5.12.17, check for updates again and reboot, you will upgrade to MIUI 6.3.17
Android Security

Keeping Internet service providers (ISPs) at bay, Google appears to be planning to add "DNS over TLS" support to Android. The new development will encrypt your domain name server (DNS) requests to massively protect your Web history and make the experience more secure and safe, without the use of any third-party virtual private network (VPN) or proxy.

Highlights of Android new 'DNS over TLS' supports:


  • The addition of "DNS over TLS" support on Android will limit the use case
  • Commits on Android Open Source Project have suggested the new development
  • Android 8.1 could be the first version to get new support

Top 10 simple tools for developing mobile application

Android Develop

Alpha Anywhere
Alpha Anywhere is a database-oriented, rapid app development tool that shines at creating Web and hybrid mobile apps that work offline. It allows developers to build good apps quickly, with surprisingly solid performance and nativelike look and feel.

Alpha Anywhere’s SQL database support is especially strong because it allows you to use the native SQL dialects of each database if you wish, or you can go with Alpha’s Portable SQL facility, which will emit the appropriate native SQL for the current database connection. Alpha’s support for offline mobile operation is also quite complete. It reduces the development of data conflict resolution logic to a few clicks.



Whatsapp Android

A multi-platform WhatsApp, removing difficulty for their user day by day. Now user of WhatsApp Android, is able to filter their notifications of whatsApp that how its appears.

Here's what the problem was: Android 8.0 Oreo, released in August 2017, introduced "notification channels" to Android phones. 

This feature is pretty convenient, in theory. It allows users to assign priority to different types of notification. For example, I could set a Facebook notification to "Urgent" importance, meaning it would make a noise and show a message on my screen, and a Facebook friend request to "Medium" importance, meaning I'd see a message, but hear no sound. 

The problem is that apps have to be individually updated by their third-party developers to include notification channel functionality. Until an app was optimized for Android 8.0 Oreo, users couldn't assign any importance to notifications from that app. 

This means for the past few months, it was impossible to change WhatsApp notifications at all. You couldn't control whether it made a noise or showed an icon, or disable certain notifications without disabling all of the app's notifications. 

There are 10 notification channels that you can now customize for different settings: group notifications, message notifications, chat history backup, critical app alerts, failure notifications, media playback, uncategorized, other notifications, sending media, and silent notifications. This means you could put high importance on your message notifications, but low importance on your group notifications, and disable uncategorized notifications, for example. 

WhatsApp did not respond to a request for comment. 

The customization is super easy to do. The next time you see a WhatsApp notification on your Android device, press and hold it, then select "All Categories." 

Then, you can choose what to do with each notification. 

FreeOffice -  A complete office suite software which is alternative of  Microsoft Office. It is light, less in size and easy to use.


FreeOffice is completely freeware software for personal use as well as business use. 
"FreeOffice is a complete office suite with a word processor, a spreadsheet application and a presentation program – all compatible with their counterparts in Microsoft Office." 

How to install custom reovery through adb and fastboot in Android Device.

Android TWRP Recovery


  1. Download TWRP recovery from here.
  2. Extract recovery.img from downloaded zip.
  3. Setup ADB and FASTBOOT (to setup use: https://drive.google.com/file/d/0B0MKgCbUM0itVVFWRC02Q0VBQnc/view

About a week and a half ago at the Google I/O conference, everyone was anticipating that Google would announce a Nexus-branded tablet during the show, and they did just that with the unveiling of the Nexus 7. But Google surprised a lot of folks by announcing a new Android-based media-streaming device, the Nexus Q, hot on the heels of the tablet. And while the Nexus 7 seems to offer great value for the money, the Nexus Q is a bit harder to figure out.

Designed to be controlled from your Android

Tips and tools for optimizing your Android Apps easily.

 - BY TIBOR KAPUTA - FREELANCE SOFTWARE ENGINEER @ TOPTAL

Android devices have a lot of cores, so writing smooth apps is a simple task for anyone, right? Wrong. As everything on Android can be done in a lot of different ways, picking the best option can be tough. If you want to choose the most efficient method, you have to know what’s happening under the hood. Luckily, you don’t have to rely on your feelings or sense of smell, since there’s a lot of tools out there that can help you find bottlenecks by measuring and describing what’s going on. Properly optimized and smooth apps greatly improve the user experience, and also drain less battery.


Let’s see some numbers first to consider how important optimization really is. According to a Nimbledroid post, 86% of users (including me) have uninstalled apps after using them only once due to poor performance. If you’re loading some content, you have less than 11 seconds to show it to the user. Only every third user will give you more time. You might also get a lot of bad reviews on Google Play because of it.


Testing your users’ patience is a shortcut to uninstallation.
The first thing every user notices over and over is the app’s startup time. According to another Nimbledroid post, out of the 100 top apps, 40 start in under 2 seconds, and 70 start in under 3 seconds. So if possible, you should generally display some content as soon as possible and delay the background checks and updates a bit.


Always remember, premature optimization is the root of all evil. You should also not waste too much time with micro optimization. You will see the most benefit of optimizing code that runs often. For example, this includes the onDraw() function, which runs every frame, ideally 60 times per second. Drawing is the slowest operation out there, so try redrawing only what you have to. More about this will come later.

Performance Tips

Powered by Blogger.