Welcome. Here you find latest freeware and legal software as well as latest info about IT Technology.
Showing posts with label Android. Show all posts
Showing posts with label Android. Show all posts
Details are light at the moment, but a bit of news out of Google’s Playtime developer event this morning: the company is launching a Google Play bug bounty program that’ll encourage researchers to poke around and look for vulnerabilities in some of Android’s most popular apps (both those built by Google and those built by third-party devs.)


Download LetterMagic here

Called the “Google Play Security Reward” program, the new program aims to get researchers to work directly with Android app developers to find vulnerabilities.

If you help a developer squash a bug, Google will pay you $1,000 (on top of whatever bounty the third-party dev themselves might pay).

Google is tapping HackerOne to handle much of the back end for this program, from submitting reports to inviting white-hat hackers into new parts of the program as they roll out. 
HACKERS can target almost ANY smart device around the world thanks to a vulnerability in WPA2 Wi-Fi security. Here's everything you should know about this threat.

By DION DASSANAYAKE
PUBLISHED: 09:20, Tue, Oct 17, 2017 | UPDATED: 09:20, Tue, Oct 17, 2017


Apple iOS, Windows, Android and any smart device that uses Wi-Fi are all at risk of an attack, cybersecurity experts have warned today.

The newly discovered KRACK exploit affects the WPA2 security protocol, a standard for Wi-Fi security used on almost every Wi-Fi router.

In theory it allows a hacker within range of a Wi-Fi network to read passwords, credit card numbers and photos sent over the internet.  

Other sensitive information that can be obtained thanks to this exploit is chat app messages and e-mails.
Its time for Augmented Reality(AR) to shine.

When Google announced its Daydream View headset last year, it was a sign that the search giant was ready to take VR to the masses. It's dabbled in VR before with Cardboard, but the View was a much more serious effort, with its fabric-clad design and user-friendly remote. Which is why it's such a surprise that Google didn't really spend a lot of time on VR at its Pixel 2 event. The company mentioned the new Daydream View -- now in colors! -- but didn't really say much more beyond that. Instead, Google was much more excited to talk about something else: AR.

Google Home
gadgets.ndtv.com
Google's much-anticipated Pixel 2, Pixel 2 XL launch event is merely a day away, and we are expecting new hardware with the company's "Made by Google" tag. The event's biggest stars are likely to be the new Pixel smartphones, but apart from them, Google is also likely to launch new Chromebook - Pixelbook, mini variant of its Home smart speaker, and the next generation of Daydream VR headsets.


Highlights:

  • A Twitter user spotted Home Mini device in Home app
  • The mini speaker likely to be priced at $49
  • Pixel 2 and Pixel 2 XL said to be biggest stars of the event


LetterMagic LogoLetter Magic 1.0

Size: 3.9MB
Download Now (ANDROID .APK)

Download From PlayStore

An awesome letter puzzle game which has one word for 4 common images. Find the correct word to unlock next level.
Play and learn new words.




*MANY LEVELS CONTINUE UPDATING* 
Guess the correct word to unlock the level. 
Countless puzzles coming soon and all will be offline. 

NO REGISTRATION 
This game will register with your existing google account automatically to save your coins and levels on cloud. 

*SIMPLE AND MORE FUN* 
Start playing game easily with lot of hints by coins.Get more coins by watching ads. 

The great Indian calendar app by XIAOMI MIUI Team. 



MIUI is giving new MIUI Calendar app that not only allows for deep customization but also offers a brand new way of discovering content that is most relevant and interesting to you.
Its has many exciting features and provides instant information of upcoming holidays, festivals, public events and much more which is beyond your thinking.

A new feature in Google Map App added that let you edit road. Let's see how to edit.

Credit: greenbot.com
Google Maps, one of the powerful, full featured navigation apps now provide editing of road within the app. Now user can easily edit the road to correct it.

Earlier this week, Google rolled out a new home-screen for Google Map users on Android in India. The company has now added the ability to edit the roads and other places. This feature is available to users of both Android and iOS apps. It is said to replace the Map Maker service that was shut down earlier this week.
You won't be able to see this new feature right away as it is hidden under other options inside the app. Here's how you can access the feature.


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.

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.

At its Google for India event in New Delhi today, the company announced a new mobile app designed with users in India in mind: YouTube Go.

The app brings YouTube to your mobile device with a slew of options to help you save on your carrier’s data fees and to work in areas with poor connectivity.

YouTube Go features video previews in the form of slideshows for each clip, so can get an idea of what it’s about before you stream or save it to your device. You can also see its file size before downloading, along with how much storage space you have left on your phone.

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

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.

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." 

Powered by Blogger.