Welcome. Here you find latest freeware and legal software as well as latest info about IT Technology.
Showing posts sorted by relevance for query iOS. Sort by date Show all posts
Showing posts sorted by relevance for query iOS. Sort by date Show all posts

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.

iPad with iOS 11

Apple's iOS 11 brings lot of new features to iPad users such as handy apps dock for quick navigation between apps and implement extra features for the use of Apple's Pencil with iPad iOS11. Now I am revealing some great and hidden features of iOS 11 for Apple's iPad.

Apple's iPad getting advance day by day, its upgraded hardware meeting with latest technology make iPad better and more better with every passing year.

In 2017, Apple pushed out iOS 11, its best software to date. This latest release is especially lovely news for iPad owners as the tablet has received a lot of attention, with a revamped interface to help speed up everyday operation.


New WhatsApp come with many features, some are hidden and some are unknown to users.

WhatsApp

  1. End-to-End Encryption: This gives full privacy over message sent and received by WhatsApp. 3rd party can't read message now.
  2. Font Format: WhatsApp recently launched a new feature for for iOS users, that allow them to format their text to add bold, italics or strikethrough option while messaging friends. The new feature was first spotted on Android version 2.12.535 which was available for Google Play beta testers, although the APK file was also online for regular users to download. iOS users need to update the app to the latest version. To add bold
Apple iOS 11.1 New Emoji
Apple on Friday revealed the new emoji that will be making their way to iOS 11.1 coming later this year. With thousands of emoji available on iPhone, iPad, Apple Watch and Mac.

New emoji include Woman with Headscarf, Bearded Person and Breastfeeding, and food items such as Sandwich and Coconut. More animals and mythical creatures like T-Rex, Zebra, Zombie and Elf are a fun way to describe situations and new Star-Struck and Exploding Head smiley faces make any message more fun.

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.


The biggest difference between iOS and Android has always been simple: Apple makes its own phones, operating system and cloud back-end, and sells essentially a single model of phone and a single model of tablet. By contrast, Google drives an open-source mobile platform, which is supported by a rich network of competing hardware makers who innovate on
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.


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.

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.

Open Whisper Systems back in December unveiled a new private messaging app for users named Signal for desktops. The app was initially available to limited users in beta. Now, the company has announced that the Signal Desktop beta is now public available.
Apple
Signal is a Chrome app which can be linked to the smartphone. This means that all incoming and outgoing messages will be displayed consistently on all connected devices. According to the company, Signal's conversations are end-to-end encrypted, and include private group, text, picture, and video messages. 

A portable device that can be used to transform smartphones into 3D Printer

OLO 3D - Convert smartphone into 3D PrinterNew York: A US-based company has designed a portable device that lets you turn any smartphone into a 3D printer using the light from the touchscreen to process your plastic creations, a media report said.
Smartphone to 3D printer
The gadget called OLO is designed to be simple to understand and operate, and is battery-operated and fully portable, weighing just 780 grams, ScienceAlert reported citing Kickstarter, the company which helped develop the creative device. 
Perfect and powerful cross-platform IDE for development of Java App, Android App, Web, PHP, Python, free for students* and have many features.


Every aspect of IntelliJ IDEA is specifically designed to maximize developer productivity.

Together, powerful static code analysis and ergonomic design make development not only productive but also an enjoyable experience.

After IntelliJ IDEA's indexed your source code, it offers blazing fast and intelligent experience by giving relevant suggestions in every context: instant and clever code completion, on-the-fly code analysis and reliable refactoring tools.

Mission-critical tools such as integrated version controls systems and a wide variety of supported languages and frameworks are at your hand — no plugin hustle included.

Powered by Blogger.