Best Smart Displays – Google Home Hub, Lenovo Smart Display, Echo Show, and more

If you want a single device to tell you the weather forecast, set your alarms, operate all your other compatible devices and do a lot more, then smart displays are worth a look. Basically it’s a smart speaker with a display, but that display makes it easier than ever to control your smart home, change playlists, and the list goes on.

While most smart displays run Google Assistant, Amazon was actually first to the game with its Alexa-powered Amazon Show.  In 2019 the smart display race continues to heat up as tech giants like Google and Amazon are in the race to offer the best.

In this article, we will take a quick look at the best smart displays the tech world has to offer.

Google Home Hub

Google Home Hub logo

Google’s first ever in-house smart display will feel familiar to you if you have tried other Google Home products.

This 7-inch and 1024 x 600 resolution display device, which comes in four colors, provides you with not only the weather report, but it also gives you a full, detailed forecast on how the temperature will be throughout the day. You can also sync in all your compatible devices with it to display your full routine for the day as soon as you say “Hey Google, good morning.” This makes it easily the best device for your bedroom. Of course that’s just scratching the surface at what a smart display can do.

One thing you won’t find here is a camera, but this helps keep the pricing down. The Google Home Hub is just $149, and you can read more about it in our detailed review here.

JBL Link View

JBL Link View Smart Display review AA 20

If you want to enjoy an exceptional stereo sound accompanied by deep bass, then this device is all you should invest in!

It comes with a built-in Chromecast support that helps you stream your favorite music and podcasts instantly. Additionally, this device has a 5MP front-facing camera along with Bluetooth support.

Have an interest in cooking? Good news! JBL Link View helps you in the kitchen too. Google guides you through the recipe step-by-step. Not only that, but it can also provide you with unit ingredient conversions like tbsp to ml and so much more.

Powered by Google Assistant and having an 8-inch screen, the JBL Link View is really the best sounding smart display. This device costs $249.95 and is a great venture for all music fans out there.

Lenovo Smart Display

Lenovo Smart Display Speaker - one of the best smart displays

While talking about the best smart displays, it will be unfair if we do not mention one of the strongest contenders for this list: the Lenovo Smart Display! Arguably the best Google Assistant powered smart display, this device provides you with an incredible visual experience. It comes in 8-inch and 10-inch display sizes.

You can control a range of smart home products, check the weather forecast, set alarms, and search up recipes. It has powerful 10W speakers that make your experience worthwhile.

Lenovo also ensures your security as it comes with a privacy shutter along with a microphone mute button. If you want the world just to be a “Hey Google” away from you, then this is the device you should invest in which will cost you $129.99 to $179.99 depending on the display size you opt for.

Amazon Echo Show 2nd Gen

An image of an Amazon Echo Show on a night stand

Amazon also offers their 8-inch, 1280 x 800 HD-display device powered by Alexa. The Amazon Echo Show 2nd Gen houses great audio as well as a visual system. Besides helping you with forecast, recipes and streaming music, this device allows you to stock up on household essentials. As soon as you run out of any item, all you have to do is ask Alexa to order it.

Echo Show also helps you to stream your favorite shows on Prime. It even comes with a 5MP camera to help you experience smooth video calling.

The device costs $229.99 and has an edge over Echo Spot which is simply just an alarm clock replacement.

Upcoming Smart Displays

KitchenAid Smart Display

KitchenAid Smart Display

As technology keeps on reaching new levels, a couple of smart displays will also roll out in 2019.

Amongst them is the KitchenAid Smart Display, powered by Google Assistant. This is going to be one of the most anticipated releases of the year if you are a fan of cooking. This smart display offers you step-by-step recipes, cooking instructions and makes shopping for ingredients even easier. It’s even waterproof. The device will probably cost somewhere between $200 and $300.

Lenovo Smart Clock

Lenovo Smart Clock

Another device that is yet to be released is the Lenovo Smart Clock. Powered by Google Assistant, this device is your ultimate bedside table companion. It works on providing you with better quality sleep with just a single command “Hey Google, good night”. Set to release in spring 2019, the affordable Lenovo Smart Clock will cost $79.99

What’s the best smart display?

As you can see, the answer to that is a bit complicated. The best smart display is definitely the one that will cater to your demands. Each of the smart displays (or clocks in the case of Lenovo) described above has its own specific qualities that make it phenomenal in its own way. Therefore, the choice you make should be based solely on what you want the device to offer you!

Source: Android Zone

The post Best Smart Displays – Google Home Hub, Lenovo Smart Display, Echo Show, and more appeared first on TuneMaster.ml.

Enjoy the safety and perks of VPN Unlimited for under $3/month

As a VPN user, I can tell you that VPNs can be game-changing — which is why the market is flooded with providers. Some are much better than others, and prices vary dramatically. If you want to balance effective performance with affordability, look no further than VPN Unlimited.

VPNs are extremely useful in this time of ever-increasing online threats. Personally, mine is never switched off. Most VPN services mask your IP address and encrypt your connection, which keeps you safe and anonymous online. That’s the least they can do though, and there are a host of other perks to enjoy.

If you want to know more about how a VPN works, check out our handy guide to VPNs. The video above also highlights some of the extra benefits a VPN can bring.

VPN Unlimited

VPN Unlimited offers everything that you should look for in a VPN, such as strong encryption, hundreds of servers, and of course, great connection speeds. It also has several features that many other VPNs don’t have, like torrenting and 24/7 customer support.

It’s also worth noting  many VPNs can’t beat the detection of streaming services, but VPN Unlimited can. If you want to access U.S. Netflix from your U.K. home, you can do it in a few clicks.

VPN Unlimited at a glance:

  • Unlimited traffic and connection speed
  • Military-grade 256-bit encryption
  • 24/7 email and instant live chat support
  • Proprietary apps
  • Torrent (P2P) servers
  • Full access to over 400 servers in more than 70 locations
  • Zero-log policy

Right now VPN unlimited has some extremely tempting deals on the table. The best VPN services are often $10 to $15 per month, and VPN Unlimited is no different. However, if you commit for a longer term, you can make some huge savings.

The pick of the offers is the three-year plan, for which you’ll pay the equivalent of just $2.78 per month. There’s a seven-day trial and money-back guarantee included, so you have nothing to lose by giving it a go.

To check out the full range of packages on offer hit the button below.

The AAPicks team writes about things we think you’ll like, and we may see a share of revenue from any purchases made through affiliate links. To see all our hottest deals, head over to the AAPICKS HUB.

Source: Android Zone

The post Enjoy the safety and perks of VPN Unlimited for under $3/month appeared first on TuneMaster.ml.

Master Android’s sensors: hardware, software and multidimensional

Today, most modern Android devices are kitted out with a bunch of sensors.

You can use this information in lots of different ways – whether it’s monitoring light levels so your application can automatically adjust its brightness or color scheme; allowing the user to interact with your mobile game using gestures such as tilting their device; or using the proximity sensor to automatically disable touch events whenever the user holds their device to their ear.

In this article, we’ll create three applications that retrieve light, proximity and motion data from a range of hardware and software sensors. We’ll also monitor these Android sensors in real time, so your application always has access to the latest information.

By the end of this article, you’ll know how to extract a single piece of data from a Android sensor, and how to handle sensors that provide their data in the form of a multidimensional array.

What Android sensors can I use?

Android sensors can be divided into the following categories:

  • Environmental sensors. These measure environmental conditions, such as air temperature, pressure, humidity and ambient light levels.

  • Position sensors. This category includes sensors that measures the device’s physical position, such as proximity sensors and geomagnetic field sensors.
    Motion sensors. These sensors measure device motion, and include accelerometers, gravity sensors, gyroscopes, and rotation vector sensors.

In addition, sensors can either be:

  • Hardware based. These are physical components that are built into the device and directly measure specific properties, such as acceleration or the strength of the surrounding geomagnetic fields.
  • Software based, sometimes known as virtual sensors or composite sensors. These typically collate data from multiple hardware-based sensors. Towards the end of this article, we’ll be working with the rotation vector sensor, which is a software sensor that combines data from the device’s accelerometer, magnetometer, and gyroscope.

Environmental sensors: Measuring ambient light

Android’s light sensor measures ambient light in “lux” units, which is the intensity of light as perceived by the human eye. The lux value reported by a sensor can vary across devices, so if your application requires consistent values then you may need to manipulate the raw data before using it in your application.

In this section, we’re going to create an application that retrieves the current lux value from the device’s light sensor, displays it in a TextView, and then updates the TextView as new data becomes available. You can then use this information in a range of apps, for example you might create a torch application that pulls information from the light sensor and then automatically adjusts the strength of its beam based on the current light levels.

Create a new Android project with the settings of your choice, and let’s get started!

Displaying your sensor data

I’m going to add a TextView that’ll eventually display the data we’ve extracted from the light sensor. This TextView will update whenever new data becomes available, so the user always has access to the latest information.

Open your project’s activity_main.xml file, and add the following:

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout 
   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"
   tools:context=".MainActivity">

   <TextView
       android:id="@+id/lightTextView"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="@string/light_sensor"
       app:layout_constraintBottom_toBottomOf="parent"
       app:layout_constraintHorizontal_bias="0.017"
       app:layout_constraintLeft_toLeftOf="parent"
       app:layout_constraintRight_toRightOf="parent"
       app:layout_constraintTop_toTopOf="parent"
       app:layout_constraintVertical_bias="0.022" />

</android.support.constraint.ConstraintLayout>

Next, we need to create the “light_sensor” string resource that’s referenced in our layout. Open your project’s strings.xml file, and add the following:

   <string name="light_sensor">Light Sensor: %1$.2f</string>

The “%1$.2f” is a placeholder that specifies the information we want to display, and how it should be formatted:

  • %1. You can insert multiple placeholders into the same string resource; “%1” indicates that we’re using a single placeholder.
  • $.2. This specifies how our application should format each incoming floating-point value. The “$.2” indicates that the value should be rounded to two decimal places.
  • F. Format the value as a floating-point number.

While some sensors are more common than others, you should never assume that every device has access to the exact same hardware and software. Sensor availability can even vary across different versions of Android, as some sensors weren’t introduced until later releases of the Android platform.

You can check whether a particular sensor is present on a device, using the Android sensor framework. You can then disable or enable parts of your application based on sensor availability, or you might display a message explaining that some of your application’s features won’t work as expected.

While we have our strings.xml file open, let’s create a “no_sensor” string, which we’ll display if the light sensor is unavailable:

   <string name="no_sensor">No light sensor available</string>

If your application cannot provide a good user experience without having access to a particular sensor, then you need to add this information to your Manifest. For example, if your app requires access to a compass sensor, then you can use the following:

<uses-feature android:name="android.hardware.sensor.compass"
  android:required="true" />

Now, your app can only be downloaded to devices that have a compass sensor.

While this may limit your audience, it’s far less damaging than allowing someone to download your application when they’re guaranteed to have a bad experience, due to their device’s sensor configuration.

Communicating with a sensor: SensorManager, SensorEvents, and listeners

To communicate with the device’s light sensor, you need to complete the following steps:

1. Obtain an instance of SensorManager

The SensorManager provides all the methods you need to access the device’s full range of sensors.

To start, create a variable that’ll hold an instance of SensorManager:

 private SensorManager lightSensorManager;

Then, you need to obtain an instance of SensorManager, by calling the Context.getSystemService method and passing in the Context.SENSOR_SERVICE argument:

       lightSensorManager = (SensorManager) getSystemService(
               Context.SENSOR_SERVICE);

2. Get a reference to lightTextView

Next, we need to create a private member variable that’ll hold our TextView objects, and assign it to our TextView:

 private TextView lightTextView;
...
...
...
    lightTextView = (TextView) findViewById(R.id.lightTextView);

3. Check whether the sensor exists on the current device

You can gain access to a particular sensor by calling the getDefaultSensor() method, and then passing it the sensor in question. The type constant for the light sensor is TYPE_LIGHT, so we need to use the following:

       lightSensor = lightSensorManager.getDefaultSensor(Sensor.TYPE_LIGHT);

If the sensor doesn’t exist on this device, then the getDefaultSensor() method will return null, and we’ll display the “no_sensor” string:

  String sensor_error = getResources().getString(R.string.no_sensor);
       if (lightSensor == null) { lightTextView.setText(sensor_error); }

   }

4. Register your sensor listeners

Every time a sensor has new data, Android generates a SensorEvent object. This SensorEvent object includes the sensor that generated the event, a timestamp, and the new data value.

Initially, we’ll be focusing on the light and proximity sensors, which return a single piece of data. However, some sensors provide multidimensional arrays for each SensorEvent, including the rotation vector sensor, which we’ll be exploring towards the end of this article.

To ensure our application is notified about these SensorEvent objects, we need to register a listener for that specific sensor event, using SensorManager’s registerListener().

The registerListener() method takes the following arguments:

  • An app or Activity Context.
  • The type of Sensor that you want to monitor.
  • The rate at which the sensor should send new data. A higher rate will provide your application with more data, but it’ll also use more system resources, especially battery life. To help preserve the device’s battery, you should request the minimum amount of data that your application requires. I’m going to use SensorManager.SENSOR_DELAY_NORMAL, which sends new data once every 200,000 microseconds (0.2 seconds).

Since listening to a sensor drains the device’s battery, you should never register listeners in your application’s onCreate() method, as this will cause the sensors to continue sending data, even when your application is in the background.

Instead, you should register your sensors in the application’s onStart() lifecycle method:

   @Override
    protected void onStart() {
        super.onStart();

//If the sensor is available on the current device...//

        if (lightSensor != null) {

//….then start listening//

            lightSensorManager.registerListener(this, lightSensor,
                    SensorManager.SENSOR_DELAY_NORMAL);
        }
    }

5. Implement the SensorEventListener callbacks

SensorEventListener is an interface that receives notifications from the SensorManager
whenever new data is available, or the sensor’s accuracy changes.

The first step, is modifying our class signature to implement the SensorEventListener interface:

public class MainActivity extends AppCompatActivity
       implements SensorEventListener {

We then need to implement the following callback methods:

onSensorChanged()

This method is called in response to each new SensorEvent.

Sensor data can often change rapidly, so your application may be calling the onSensorChanged() method on a regular basis. To help keep your application running smoothly, you should perform as little work as possible inside the onSensorChanged() method.

@Override
    public void onSensorChanged(SensorEvent sensorEvent) {

//To do//

    }
onAccuracyChanged()

If the sensor’s accuracy improves or declines, then Android will call the onAccuracyChanged() method and pass it a Sensor object containing the new accuracy value, such as SENSOR_STATUS_UNRELIABLE or SENSOR_STATUS_ACCURACY_HIGH.

The light sensor doesn’t report accuracy changes, so I’ll be leaving the onAccuracyChanged() callback empty:

   @Override
    public void onAccuracyChanged(Sensor sensor, int i) {

//To do//

    }
}

6. Retrieve the sensor value

Whenever we have a new value, we need to call the onSensorChanged() method, and retrieve the “light_sensor” string. We can then override the string’s placeholder text (%1$.2f) and display the updated string as part of our TextView:

@Override

   public void onSensorChanged(SensorEvent sensorEvent) {

//The sensor’s current value//

       float currentValue = sensorEvent.values[0];

//Retrieve the “light_sensor” string, insert the new value and display it to the user//

    lightTextView.setText(getResources().getString(
               R.string.light_sensor, currentValue));
   }

7. Unregister your listeners

Sensors can generate large amounts of data in a small amount of time, so to help preserve the device’s resources you’ll need to unregister your listeners when they’re no longer needed.

To stop listening for sensor events when your application is in the background, add unregisterListener() to your project’s onStop() lifecycle method:

   @Override
    protected void onStop() {
        super.onStop();
        lightSensorManager.unregisterListener(this);
    }

Note that you shouldn’t unregister your listeners in onPause(), as in Android 7.0 and higher applications can run in split-screen and picture-in-picture mode, where they’re in a paused state, but remain visible onscreen.

Using Android’s light sensors: Completed code

After completing all the above steps, your project’s MainActivity should look something like this:

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.content.Context;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity

//Implement the SensorEventListener interface//

       implements SensorEventListener {

//Create your variables//

   private Sensor lightSensor;
   private SensorManager lightSensorManager;
   private TextView lightTextView;

   @Override
    protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);
       lightTextView = (TextView) findViewById(R.id.lightTextView);

//Get an instance of SensorManager//

       lightSensorManager = (SensorManager) getSystemService(
              Context.SENSOR_SERVICE);

//Check for a light sensor//

       lightSensor = lightSensorManager.getDefaultSensor(Sensor.TYPE_LIGHT);

//If the light sensor doesn’t exist, then display an error message//

       String sensor_error = getResources().getString(R.string.no_sensor);
       if (lightSensor == null) { lightTextView.setText(sensor_error); }

   }

   @Override
    protected void onStart() {
        super.onStart();

//If the sensor is available on the current device...//

       if (lightSensor != null) {

//….then register a listener//

       lightSensorManager.registerListener(this, lightSensor,

//Specify how often you want to receive new data//

                   SensorManager.SENSOR_DELAY_NORMAL);
       }
   }

   @Override
    protected void onStop() {
       super.onStop();

//Unregister your listener//

       lightSensorManager.unregisterListener(this);
   }

   @Override
    public void onSensorChanged(SensorEvent sensorEvent) {

//The sensor’s current value//

       float currentValue = sensorEvent.values[0];

//Retrieve the “light_sensor” string, insert the new value and update the TextView//

       lightTextView.setText(getResources().getString(
               R.string.light_sensor, currentValue));
}

   @Override

//If the sensor’s accuracy changes….//

    public void onAccuracyChanged(Sensor sensor, int i) {

//TO DO//

   }
}

Test your completed Android sensor app

To test this application on a physical Android smartphone or tablet:

  • Install the project on your device (by selecting “Run > Run” from the Android Studio toolbar).
  • Although it varies between devices, the light sensor is often located on the upper-right of the screen. To manipulate the light levels, move your device closer to, and then further away from a light source. Alternatively, you could try covering the device with your hand, to block out the light. The “Light Sensor” value should increase and decrease, depending on the amount of light available.

If you’re using an Android Virtual Device (AVD), then the emulator has a set of virtual sensor controls that you can use to simulate various sensor events. You access these virtual sensor controls, via the emulator’s “Extended Controls” window:

  • Install the application on your AVD.
  • Alongside the AVD, you’ll see a strip of buttons. Find the three-dotted “More” button (where the cursor is positioned in the following screenshot) and give it a click. This launches the “Extended Controls” window.

  • In the left-hand menu, select “Virtual sensors.”
  • Select the “Additional sensors” tab. This tab contains various sliders that you can use to simulate different position and environmental sensor events.

  • Find the “Light (lux)” slider and drag it left and right, to change the simulated light levels. Your application should display these changing values, in real time.

You can download the completed project from GitHub.

Measuring distance, with Android’s proximity sensors

Now we’ve seen how to retrieve information from an environmental sensor, let’s look at how you’d apply this knowledge to a position sensor.

In this section, we’ll use the device’s proximity sensor to monitor the distance between your smartphone or tablet, and other objects. If your application has any kind of voice functionality, then the proximity sensor can help you determine when the smartphone is being held to the user’s ear, for example when they’re having a telephone conversation. You can then use this information to disable touch events, so the user doesn’t accidentally hang up, or trigger other unwanted events mid-conversation.

Creating the user interface

I’m going to display the proximity data onscreen, so you can watch it update in real time. To help keep things simple, let’s reuse much of the layout from our previous application:

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout 
   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"
   tools:context=".MainActivity">

 <TextView
       android:id="@+id/proximityTextView"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="@string/proximity_sensor"
       app:layout_constraintBottom_toBottomOf="parent"
       app:layout_constraintHorizontal_bias="0.017"
       app:layout_constraintLeft_toLeftOf="parent"
       app:layout_constraintRight_toRightOf="parent"
       app:layout_constraintTop_toTopOf="parent"
       app:layout_constraintVertical_bias="0.022" />

</android.support.constraint.ConstraintLayout>

Next, open your strings.xml file and create a “proximity_sensor” string. Once again, this string needs to contain a placeholder, which will eventually be populated by data extracted from the proximity sensor:

<resources>
   <string name="app_name">ProximitySensor</string>
   <string name="proximity_sensor">Proximity Sensor: %1$.2f</string>
   <string name="no_sensor">No proximity sensor available</string>
</resources>

Getting data from the proximity sensor

Similar to the light sensor, Android’s proximity sensor returns a single data value, which means we can reuse much of the code from our previous application. However, there are a few major differences, plus some name-related changes that make this code easier to follow:

  • Create an instance of SensorManager, which this time around I’m going to name “proximitySensorManager.”
  • Obtain an instance of “proximitySensorManager.”
  • Create a reference to the “proximityTextView.”
  • Call the getDefaultSensor() method, and pass it the TYPE_PROXIMITY sensor.
  • Register and unregister listeners for the proximity sensor.

After making these tweaks, you should end up with the following:

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.content.Context;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorManager;
import android.hardware.SensorEventListener;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity

//Implement the SensorEventListener interface//

       implements SensorEventListener {

//Create your variables//

   private Sensor proximitySensor;
   private SensorManager proximitySensorManager;
   private TextView proximityTextView;

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

        proximityTextView = (TextView) findViewById(R.id.proximityTextView);

//Get an instance of SensorManager//

        proximitySensorManager = (SensorManager) getSystemService(
                Context.SENSOR_SERVICE);

//Check for a proximity sensor//

       proximitySensor = proximitySensorManager.getDefaultSensor(
               Sensor.TYPE_PROXIMITY);

//If the proximity sensor doesn’t exist, then display an error message//

       String sensor_error = getResources().getString(R.string.no_sensor);

       if (proximitySensor == null) {
           proximityTextView.setText(sensor_error);
       }
   }

   @Override
   protected void onStart() {
       super.onStart();

//If the sensor is available on the current device...//

       if (proximitySensor != null) {

//….then register a listener//

           proximitySensorManager.registerListener(this, proximitySensor,

//Specify how often you want to receive new data//

                   SensorManager.SENSOR_DELAY_NORMAL);
       }

   }

   @Override
   protected void onStop() {
    super.onStop();

//Unregister your listener to preserve system resources//

       proximitySensorManager.unregisterListener(this);
   }

   @Override
   public void onSensorChanged(SensorEvent sensorEvent) {

//The sensor’s current value//

       float currentValue = sensorEvent.values[0];

//Retrieve the “proximity_sensor” string, insert the new value and update the TextView//

       proximityTextView.setText(getResources().getString(
               R.string.proximity_sensor, currentValue));
   }
    
   @Override

//If the sensor’s accuracy changes….//

   public void onAccuracyChanged(Sensor sensor, int i) {

//...TO DO//

   }
}

Testing: How close is the user to their device?

To put this application to the test on a physical Android smartphone or tablet, install the application on your device and then experiment by moving your hand towards the screen, and then moving it away again. The “Proximity Sensor” value should record your movements.

Just be aware that proximity sensors can vary between devices. Some devices may only display two proximity values – one to indicate “Near” and one to indicate “Far” – so don’t be surprised if you don’t see much variety on your physical Android device.

To test this application on an emulator:

  • Install your application on an AVD.
  • Find the three-dotted “More” button and give it a click, which launches the “Extended Controls” window.
  • In the window’s left-hand menu, select “Virtual sensors.”
  • Select the “Additional sensors” tab.
  • Find the “Proximity” slider, and drag it left and right to emulate an object moving closer to the device, and then further away. The “Proximity Sensor” values should change, as you manipulate the slider.

You can download the completed project from GitHub.

Motion sensors: Processing multidimensional arrays

Up until this point, we’ve focused on sensors that supply a single item of data, but there are some sensors that provide multidimensional arrays for each SensorEvent. These multidimensional sensors include motion sensors, which we’ll be focusing on in this final section.

Motion sensors can help you:

  • Provide an alternative method of user input. For example, if you’re developing a mobile game then the user might move their character around the screen by tilting their device.
  • Infer user activity. If you’ve created an activity-tracking app, then motion sensors can help you gauge whether the user is travelling in a car, jogging, or sitting at their desk.
  • More accurately determine orientation. It’s possible to extract coordinates from a device’s motion sensors, and then translate them based on the Earth’s coordinate system, to get the most accurate insight into the device’s current orientation.

In this final section, we’ll be using the rotation vector sensor (TYPE_ROTATION_VECTOR). Unlike the light and proximity sensors, this is a software sensor that collates data from the device’s accelerometer, magnetometer, and gyroscope sensors. Although working with this sensor often requires you to perform mathematical conversions and transformations, it can also provide you with a range of highly-accurate information about the device.

We’ll be creating an application that uses the rotation vector sensor to measure:

  • Pitch. This is the top-to-bottom tilt of the device.
  • Roll. This is the left-to-right tilt of the device.

Displaying real time pitch and roll data

Since we’re measuring two metrics, we need to create two TextViews and two corresponding string resources:

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout 
   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"
   tools:context=".MainActivity">

   <TextView
       android:id="@+id/pitchTextView"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:layout_margin="10dp"
       android:layout_marginStart="8dp"
       android:layout_marginTop="12dp"
       android:layout_marginEnd="8dp"
       android:text="@string/pitch_sensor"
       app:layout_constraintEnd_toEndOf="parent"
       app:layout_constraintHorizontal_bias="0.0"
       app:layout_constraintStart_toStartOf="parent"
       app:layout_constraintTop_toTopOf="parent" />

   <TextView
       android:id="@+id/rollTextView"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:layout_marginStart="8dp"
       android:layout_marginTop="8dp"
       android:layout_marginEnd="8dp"
       android:text="@string/roll_sensor"
       app:layout_constraintEnd_toEndOf="parent"
       app:layout_constraintHorizontal_bias="0.0"
       app:layout_constraintStart_toStartOf="parent"
       app:layout_constraintTop_toBottomOf="@+id/pitchTextView" />

</android.support.constraint.ConstraintLayout>

Open the strings.xml file, and add the following:

<resources>
   <string name="app_name">MotionSensors</string>
   <string name="pitch_sensor">Pitch Sensor: %1$.2f</string>
   <string name="roll_sensor">Roll Sensor: %1$.2f</string>
   <string name="no_sensor">No motion sensor available</string>
</resources>

Using the rotation vector sensor in your app

We’ll be re-using some of the code from our previous applications, so let’s focus on the areas where communicating with the rotation vector sensor, is significantly different to what we’ve seen before.

1. Use the TYPE_ROTATION_VECTOR

Since we’re working with the rotation vector sensor, we need to call the getDefaultSensor() method, and then pass it the TYPE_ROTATION_VECTOR constant:

positionSensorManager.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR);

2. Translate the sensor data

Unlike the previous light and proximity sensors, motion sensors return multidimensional arrays of sensor values for every SensorEvent. These values are formatted using the standard “X, Y, Z” coordinate system, which is calculated relative to the device when it’s held in its default, “natural” orientation.

Android doesn’t switch these X, Y and Z coordinates around to match the device’s current orientation, so the “X” axis will remain the same regardless of whether the device is in portrait or landscape mode. When using the rotation vector sensor, you may need to convert the incoming data to match the device’s current rotation.

Portrait is the default orientation for most smartphones, but you shouldn’t assume this is going to be the case for all Android devices, particularly tablets. In this article, we’ll use a rotation matrix to translate the sensor’s data from its original, device coordinate system, to the Earth’s coordinate system, which represents the device’s motion and position relative to the Earth. If required, we can then remap the sensor data, based on the device’s current orientation.

Firstly, the device coordinate system is a standard 3-axis X, Y, Z coordinate system, where each point on each of the three axes is represented by a 3D vector. This means we need to create an array of 9 float values:

       float[] rotationMatrix = new float[9];

We can then pass this array to the getRotationMatrix() method:

       SensorManager.getRotationMatrixFromVector(rotationMatrix, vectors);
       int worldAxisX = SensorManager.AXIS_X;
       int worldAxisZ = SensorManager.AXIS_Z;

The next step, is using the SensorManager.remapCoordinateSystem() method to remap the sensor data, based on the device’s current orientation.

The SensorManager.remapCoordinateSystem() method takes the following arguments:

  • The original rotation matrix.
  • The axes that you want to remap.
  • The array that you’re populating with this new data.

Here’s the code I’ll be using in my app:

  float[] adjustedRotationMatrix = new float[9];
       SensorManager.remapCoordinateSystem(rotationMatrix, worldAxisX, worldAxisZ, adjustedRotationMatrix);

Finally, we’ll call SensorManager.getOrientation and tell it to use the adjustedRotationMatrix:

       SensorManager.getOrientation(adjustedRotationMatrix, orientation);

3. Update the placeholder strings

Since we have two sets of data (pitch and roll), we need to retrieve two separate placeholder strings, populate them with the correct values, and then update the corresponding TextView:

    pitchTextView.setText(getResources().getString(
               R.string.pitch_sensor,pitch));
       rollTextView.setText(getResources().getString(
              R.string.roll_sensor,roll));

Displaying multiple sensor data: Completed code

After performing the above steps, your MainActivity should look something like this:

import android.app.Activity;
import android.os.Bundle;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.widget.TextView;

public class MainActivity extends Activity implements SensorEventListener {

   private SensorManager motionSensorManager;
   private Sensor motionSensor;
   private TextView pitchTextView;
   private TextView rollTextView;

   private static final int SENSOR_DELAY = 500 * 1000;
   private static final int FROM_RADS_TO_DEGS = -57;

   @Override
       protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);
       pitchTextView = (TextView) findViewById(R.id.pitchTextView);
       rollTextView = (TextView) findViewById(R.id.rollTextView);

       try {
           motionSensorManager = (SensorManager) getSystemService(Activity.SENSOR_SERVICE);
           motionSensor = motionSensorManager.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR);
           motionSensorManager.registerListener(this, motionSensor, SENSOR_DELAY);
       } catch (Exception e) {
           pitchTextView.setText(R.string.no_sensor);
           rollTextView.setText(R.string.no_sensor);

       }
   }

   @Override
   public void onAccuracyChanged(Sensor sensor, int accuracy) {

//To do//

   }

   @Override
   public void onSensorChanged(SensorEvent event) {
       if (event.sensor == motionSensor) {
           update(event.values);
       }
   }

   private void update(float[] vectors) {

//Compute the rotation matrix//

       float[] rotationMatrix = new float[9];
       SensorManager.getRotationMatrixFromVector(rotationMatrix, vectors);
       int worldAxisX = SensorManager.AXIS_X;
       int worldAxisZ = SensorManager.AXIS_Z;

//Remap the matrix based on the Activity’s current orientation//

       float[] adjustedRotationMatrix = new float[9];
       SensorManager.remapCoordinateSystem(rotationMatrix, worldAxisX, worldAxisZ, adjustedRotationMatrix);

//Compute the device's orientation//

       float[] orientation = new float[3];

//Supply the array of float values to the getOrientation() method//

      SensorManager.getOrientation(adjustedRotationMatrix, orientation);
      float pitch = orientation[1] * FROM_RADS_TO_DEGS;
      float roll = orientation[2] * FROM_RADS_TO_DEGS;

//Update the TextViews with the pitch and roll values//

       pitchTextView.setText(getResources().getString(
               R.string.pitch_sensor,pitch));
       rollTextView.setText(getResources().getString(
               R.string.roll_sensor,roll));

   }

}

You can download the completed project from GitHub.

Testing our final Android sensor application

To test this rotation vector Android sensor app on a physical Android smartphone or tablet:

  • Install the application on your device.
  • Place your smartphone or tablet on a flat surface. Note that motion sensors are extremely sensitive, so it’s not unusual for a seemingly-motionless device to report fluctuations in pitch and roll values.
  • To test the pitch, lift the bottom of your device so that it’s tilting away from you. The pitch value should change dramatically.
  • To test the roll, try lifting the left-hand side of your device, so it’s tilting to the left – keep an eye on that roll value!

If you’re testing your project on an emulator:

  • Install the application on your AVD.
  • Select “More,” which launches the “Extended Controls” window.
  • In the left-hand menu, select “Virtual sensors.”
  • Make sure the “Accelerometer” tab is selected. This tab contains controls that can simulate changes in the device’s position and orientation.
  • Try experimenting with the various sliders (Rotate: Z-Rot, X-Rot, Y-Rot; and Move: X, Y, and Z) and the various “Device Rotation” buttons, to see how they affect your application’s “Roll Sensor” and “Pitch Sensor” values.

Android sensors - how they work

Wrapping up

In this article, we saw how to retrieve data from the three main categories of Android sensors: environmental, position and motion, and how to monitor this data in real time.

Have you seen any Android apps that use sensors in interesting or unique ways? Let us know in the comments below!

Source: Android Zone

The post Master Android’s sensors: hardware, software and multidimensional appeared first on TuneMaster.ml.

4 best smart plugs you can buy

Forgot to switch off the TV before leaving home? Don’t feel like getting out of bed in the morning to make coffee? Smart plugs are your one-stop solution to upgrading your conventional home appliances into smart devices.

A smart plug is a simple device that can control almost any electronic device straight from your smartphone or a smart speaker. While they can’t do much more than turn them off or on, there’s plenty of scenarios where these could come in handy, as mentioned above.

We’ve narrowed down a list of the best smart plugs for 2019, so lets jump right in.

Belkin Wemo Mini Smart Plug

Wemo Mini Smart Plug

With the Wemo Mini smart plug you can effortlessly manage all your connected devices irrespective of where you are. Being wireless, this smart plug allows you to control your gadgets by a simple on/off button through your smartphone or tablet. Another positive thing to consider is its remarkably compact size. Furthermore, when used with virtual assistants like Google Assistant and Amazon Alexa, this plug offers you a full voice control support. 

You can buy this product for just $ 18.99 and can explore its exceptional features.

Get it on Amazon

Belkin Wemo Insight Smart Plug

Wemo Insight Smart Plug

Another one from Wemo, the Belkin Wemo Insight Smart Plug can control other devices in your home using the WiFi, and can remotely turn them on and off. This gives you access and control over these devices from anywhere.

It informs you about the power your device is using, how long it’s been on, and how much money it costs you in terms of energy consumption. You can also use it with an IFTT recipe and can schedule it according to your convenience.

Wemo Insight also works with Google Assistant and Alexa. It even has a feature that connects to Nest so it can tell your Wemo when you’re home or away. This way your electrical appliances can turn off to conserve energy when the house is empty or your lights can turn on automatically when you walk in the door.

Smart and exciting, right? However, this one costs $35 which makes it the most expensive smart plug on our list. However, it is also the most advanced and high-tech, so you get the best value for your money.

Get it on Amazon

Xiaomi Mi Smart Plug

 Xiaomi Smart WiFi Socket

The third on our list of the top-ranked smart plugs is the Mi Smart Plug, a product by China’s third largest e-commerce company and tech giant, Xiaomi. It stands out because of its super affordable price and compact design. Its tiny glossy case is made of flame-resistant material and can withstand a temperature of up to 750°C.

You can wirelessly control the functions of your home devices from anywhere simply by using either your smartphone or voice control via Google Assistant. In addition, it used a 5V/1A USB port, that allows you to easily charge a USB device. Available for only $17, this one makes the cheapest smart plug on our list.

Get it on Amazon

Aukey Wi-Fi Smart Plug

AUKEY Wi-Fi Smart Plug

What’s better than a single smart plug? Its two manual, App and voice assistant controlled outlet plugs for the price of one! Aukey’s unique compact form lets two smart plugs to fit together perfectly in one duplex outlet.

Using Google Assistant, Alexa or the Aukey Home App, you can easily change settings on your electric devices from anywhere. You can even program your home appliances so that they switch on and off on their own based on your daily routine.

Available for only $27.99, this one is not only a smart plug, but also makes for a smart investment. You also get two smart plugs in a set for this price.

With the advent of ‘smart’ technology and the constant need to upgrade our lives along with 2it, smart plugs are a simple way to bring just a little bit of smarts to your devices without investing much. The above-listed options are some of the best smart plugs in 2019, and your first step into transforming your traditional home into a high-tech one.

Related:

Affiliate disclosure: We may receive compensation in connection with your purchase of products via links on this page. The compensation received will never influence the content, topics or posts made in this blog. See our disclosure policy for more details.

Source: Android Zone

The post 4 best smart plugs you can buy appeared first on TuneMaster.ml.

Why you should (and why you shouldn’t) buy a used smartphone

To buy a used smartphone, or not to buy a used smartphone? For the frugal folks among us, the question seems fairly self-explanatory: used phones are cheaper, therefore the better bargain.

However, that might not always be the case. Over the past few years, the budget and mid-range categories of smartphones have exploded, with brand new models sometimes performing as well — or even better — than other devices which cost twice as much. There are even newer companies that specialize only in phones that deliver a high-end experience for as little cash as possible.

Granted, sometimes you need something specific — something you can only get from one particular brand or style of device. In that case, if you were to buy a used smartphone you might be making the best move.

Let’s get more in-depth on this topic. First, let’s start with the reasons to buy a used phone.

Why you should buy a used phone

In general, the only real reason to buy a used phone is if you absolutely need a certain feature, design style, or brand. The best way to decide whether or not to buy used is to think about your smartphone deal-breakers.

For example, one of the most important smartphone features for many consumers is the camera. If you are a shutterbug and use your smartphone to take tons of photos, you’re going to need something that gives you the best output possible. However, if you’re also on a budget you might not be able to afford the best-in-class Huawei Mate 20 Pro or the Google Pixel 3 XL.

Editor’s Pick

This would be the perfect reason to buy a used phone. If you could find those devices for a good price on eBay, Swappa, or another second-hand site, that would make sense. You could even go a generation back to save more — the Google Pixel 2 XL, for example, has almost as good a camera as the 3 XL and has many of the same features.

On the other hand, the latest-and-greatest features may not be what you’re looking for, and in that case you might actually want to take a step back. For example, almost every flagship device from 2018 features a rear-mounted fingerprint scanner or an in-display fingerprint scanner. If you really want a device with a physical scanner on the front, buying an older flagship used could be your best bet. In this case, something like the Huawei P20 Pro would be a great choice, which is much cheaper now than it was when it launched and is still getting software support from Huawei.

There are plenty of great reasons to buy a used phone, but ‘they are always cheaper’ isn’t exactly the best one.

Maybe you have small hands and thus need a phone with a smaller design factor, or maybe you love the Galaxy Note line’s included stylus and want the Samsung Galaxy Note 9 at a cheaper price. These are also good reasons to buy a specific device used.

It should be noted that used phones come with limitations. Some of them have no warranty, some will come with knicks or other cosmetic blemishes, some will be missing accessories, etc. However, if you desperately need a particular feature and the best (or only) way to get it at a decent price is to buy used, then that’s absolutely what you should do.

If you do decide to buy used, be sure to read our article here on the do’s and don’ts of buying a used smartphone. But don’t go there quite yet! You should read the next section first.

Why you shouldn’t buy a used smartphone

The back of the OnePlus 6T

The smartphone industry has changed quite a bit in the past few years. Previously, if you wanted the newest, coolest features, you had no other choice but to buy the latest-and-greatest smartphone. There was no way around it.

However, innovation within the industry as a whole has slowed down a lot. Nowadays, you could pick any Android flagship at random and chances would be good that it would have the same core features as any other. Yes, there will always be one or two things a flagship from Company A will have that Company B doesn’t, but it’s not likely to be a deal-breaker for the general consumer.

Editor’s Pick

With that in mind, the features of the high-end flagship Android devices and the features of the mid-range are quickly becoming very similar. As such, you can buy a brand new smartphone with all the core features you need for a similar price as buying a used flagship.

If you can get everything you want from a brand new phone at the same price as a used one, why would you buy used?

Take the Xiaomi Pocophone F1, for example. The device has a huge battery (4,000mAh), the Qualcomm Snapdragon 845 processor (still the latest and best), and either 6GB or 8GB of RAM. Depending on where you live, you can get this phone for between $300-$400, brand new.

If you don’t have many specific deal-breakers when it comes to smartphones, a brand new mid-ranger is the better decision.

The OnePlus 6 and OnePlus 6T have similar specs to the Pocophone F1, but more premium build materials and better availability by country. The starting price for the OnePlus 6 is $530, brand new.

The mid-range market is only growing, too. The 2019 Honor View 20, for example, is getting stellar reviews — including from here at Android Authority — and features a nearly all-screen display, a headphone jack, an IR blaster, and terrific specs and build quality. Although it’s only available in China at the moment, we anticipate its global price to start at less than $500.

Another thing that these newer smartphones will have over their older, used counterparts, is software updates. Every device given as an example in this section will get Android security updates for at least another year, probably two. They also will all likely receive an update to Android Q, which something not every older used phone is going to offer you.

With that in mind though, don’t forget that there are still plenty of new units of older generations of flagships out there. A quick perusal of eBay shows plenty of brand new units of the Google Pixel 2, the Samsung Galaxy Note 8, the LG G7 ThinQ, the Huawei Mate 10 Pro, etc. Even though these devices are unused and still in the box, they’re selling for much less than their newer counterparts. Yes, they might not get updates for much longer, but they are still viable options.

What should you do?

Buying used phones is a great way to save money.. but not always

If you’re in the market for a new phone, you should think about what you absolutely can’t live without. If one of those deal-breakers is a feature you can only get from a specific brand or specific model of a device, then buying used will be the best way to save money.

If you don’t have too many deal-breakers or the deal-breakers you do have are relatively common (such as needing a headphone jack or a great camera), just buy a mid-ranger brand new. You’ll get a warranty, you’ll probably be more likely to get software updates, and you won’t have to worry about cosmetic blemishes, missing accessories, etc.

Either way, check out our guide here on buying a used smartphone or check out our other guide here on the best mid-range devices around right now.

Source: Android Zone

The post Why you should (and why you shouldn’t) buy a used smartphone appeared first on TuneMaster.ml.

Huawei indicted, China responds. Should consumers worry?

Huawei Mate 20 Pro vs P20 Pro Camera

The U.S. socked Huawei right in the mouth with the power of a heavyweight boxer. The Department of Justice this week filed indictments against the company, alleging it stole trade secrets, violated trade sanctions against Iran, and committed fraud. Everyone knew the hit was coming, but that doesn’t stop it from smarting.

The indictments are part of a years-long campaign by the U.S. to minimize Huawei’s reach in the telecommunications market over what it says are legitimate security concerns. Some believe the Chinese government has a backdoor into Huawei’s telecommunications gear that could be used for spying. The company has long denied any wrongdoing and asserted those claims once again in the wake of the latest action.

“Huawei is disappointed to learn of the charges brought against the company,” said the company today in a statement. The charges are aimed at Huawei CFO Wanzhou Meng, who was arrested in Canada last year. The U.S. hopes to extradite Meng and force her (and Huawei) to face trial. Huawei says it reached out to the U.S. after Meng was arrested, but was rebuffed. “The company … is not aware of any wrongdoing by Ms. Meng, and believes the U.S. courts will ultimately reach the same conclusion.”

The Chinese foreign ministry also leveled a new complaint against the DoJ. “We strongly urge the United States to stop the unreasonable crackdown on Chinese companies including Huawei,” said Foreign Ministry spokesperson Geng Shuang in a statement. The Ministry further urged the U.S. to “immediately withdraw the arrest warrant” and “stop making such kinds of extradition requests.”

The charges

Huawei has to play the short and long game at the same time, and navigate both skillfully if it wants to extricate itself from this ever-growing threat.

The U.S. case focuses on some fairly specific incidents. It alleges that a Hong Kong-based subsidiary, Skycom, acted as a front for Huawei’s activities in Iran. Skycom’s Iran offices were staffed by locals, but acted at the behest of Huawei to strike deals in violation of international trade sanctions in place against Iran. Bank fraud is lumped in with this charge. Meng was roped in due to her role as chief financial officer, a position that would have allowed to her to oversee such behavior.

The U.S. also says Huawei engineers in the U.S. attempted to steal trade secrets from T-Mobile. This case, settled some time ago, involved a testing robot called Tappy. A jury has already awarded T-Mobile $4.8 million.

Huawei claims its employees acted on their own (lone wolf defense), while the U.S. says it can prove the employees acted on the company’s behalf.

The actual theft of Tappy secrets isn’t that important, noted Tim Culpan, a Bloomberg contributor, via Twitter. It’s more important to learn whether company management was part of the plot and whether its lone wolf defense is legit. This will eventually establish — or strip away — trust in Huawei’s leadership.

Consumer impact

Can Huawei counter this in a meaningful way, and what might the impacts be on consumers?

While the company’s telecommunications gear has been banned in the U.S. for some time, Washington has only recently succeeded in making other countries question Huawei. Vodafone in Europe, for example, said it would pause purchases of Huawei equipment while it reevaluates its relationship with the company. Vodafone is one of the biggest carriers across the continent.

This shows things are beginning to turn south for Huawei’s telco biz.

Should carriers begin to source equipment from Huawei’s competitors, it will affect global 5G build-outs eventually. Carriers are set to begin deploying 5G in earnest over the next six to 18 months. Losing a major supplier could slow things down. This isn’t the worst possible outcome.

Then there’s Huawei’s other business: mobile phones. There’s still time for the company to shield its handsets from the fallout.

“Huawei really needs to separate its devices business from [its] telecom infrastructure,” recommends Avi Greengart, research director, consumer platforms & devices, at GlobalData.

Huawei has in the last year become the world’s second-largest supplier of cell phones. This includes its Honor-branded devices. Huawei sits between number one Samsung and number three Apple. It might consider divesting the business entirely. Maybe rebrand the entire phone business under the Honor umbrella, or come up with a new brand. Put a clear, internal wall to separate the telecommunications business from the phone business. Doing so might ease some minds and allow Huawei’s phone unit to continue innovating.

Innovation is key. With 5G around the corner, phones are about to get exciting again. It would be a shame to see the number two player, which has delivered some of the most compelling phones in the last year, knocked down. 

Huawei’s path forward is a bit murky. It must first prevent Meng’s extradition to the U.S. If it cannot, it needs to mount a successful lone wolf defense for those accused of breaking the law. Should Huawei lose the case entirely, its reputation will suffer severely and its telco business may be in immediate most danger. Consumers needn’t worry overmuch for the time being. 

Source: Android Zone

The post Huawei indicted, China responds. Should consumers worry? appeared first on TuneMaster.ml.

Gmail for mobile is getting a Material Theme redesign that is mostly white space

Google

Slowly but surely, Google has been pushing its new Material Theme to its various services. After rolling out a major overhaul to Gmail on the web back in September, Google has announced that the redesign is coming to the Gmail mobile apps.

If you’ve used the web client, this refresh won’t come as much of a surprise. As you can see from the screenshots, Gmail will be removing most of the app’s accent colors and sticking with a flat white design. The various smart groups and alerts will retain Google’s bright colors to help users distinguish between different areas of the app.

With Android Q’s rumored push for a system-wide dark mode, fingers crossed that Gmail soon offers a way to tone down the bright design.

Editor’s Pick

Google notes that the redesign will introduce an easier way to switch between email accounts and will offer a default, comfortable, and compact style for viewing emails similar to what’s available on the web. This focus on ease of use and customization is likely to help Inbox users transition back to Gmail as that service comes to an end.

Gmail apps on Android and iOS will receive this redesign in the next couple of weeks. Google plans to roll out a similar Material Theme to the rest of the G Suite mobile apps throughout the year.

Source: Android Zone

The post Gmail for mobile is getting a Material Theme redesign that is mostly white space appeared first on TuneMaster.ml.

Huawei’s problems are China’s problems, and the country is now reacting

Huawei logo MWC

  • Yesterday’s news about legal action from the U.S. towards Huawei has China very concerned.
  • In response, the country is pledging to help keep Huawei growing domestically through a series of programs.
  • The vested interest from China in Huawei’s success doesn’t help assuage fears about the connections between the two.

Over the past decade, Huawei has turned from a promising Chinese telecommunications company into a global powerhouse. Huawei is currently the second-largest smartphone manufacturer in the world, and could very likely become the top dog by the end of this year.

Huawei has become so big that the company’s financial reports and China’s economy are becoming ever-more linked together. If Huawei struggles, China struggles.

For example, according to data from the Internet Society of China (via South China Morning Post), services and products in China that rely on an internet connection were worth 5 trillion yuan (~$741 billion) in 2018, accounting for about six percent of the entire country’s GDP. Huawei products likely make up an enormous chunk of that six percent.

Editor’s Pick

That’s why China has a genuine vested interest in making sure Huawei is successful. After the laying of formal charges against Huawei from the United States government yesterday, China itself needs to react accordingly.

As such, China recently pledged to ramp up efforts within the country to increase Huawei’s profits. Those efforts will include:

  • Fast-tracking 5G rollouts around the country
  • Fast-tracking the rollout of 4K television channels
  • Subsidizing high-definition television sets as well as select VR/AR products
  • Encouraging citizens to increase their “information consumption”

In other words, China knows that Huawei is going to struggle for the foreseeable future when it comes to global expansion and is responding by increasing domestic consumption of Huawei products.

Huawei’s problems are clearly China’s problems as well, which doesn’t help quell fears about the links between the two entities.

Of course, one of the main reasons there’s so much going against Huawei throughout the world is the assumption that the company is secretly tied to the Chinese government and builds “back doors” into its products which could be used for spying on foreign countries. The fact that China is responding this way to Huawei’s problems doesn’t exactly help in dissuading other countries from thinking that the two entities are so intertwined.

The term “too big to fail” comes to mind when thinking about this relationship, and we all know how well that phrase is viewed here in the United States. However, it’s still unclear just how much these problems Huawei faces around the world will affect its bottom line, considering it’s done nothing but grow every quarter for years.

Regardless, Huawei (and thus, China) is on its toes as previous issues surrounding ZTE show that the U.S. has a substantial amount of power when it comes to hurting Chinese companies. It will be interesting to see how this pans out.

NEXT: Huawei says it could become #1 smartphone maker in the world this year

Source: Android Zone

The post Huawei’s problems are China’s problems, and the country is now reacting appeared first on TuneMaster.ml.

Find website flaws fast and save 70% with Checkbot for Chrome

Checkbot for Chrome

Does your business rely on a website? Keep it running in tip-top shape with Checkbot for Chrome, offered to readers for the heavily reduced price of just $29.99.

Checkbot is a web master’s best friend. It’s a Chrome extension that monitors your website — all of them at once, in fact — and locates coding errors, broken links, and even identifies deficiencies in search engine optimization, security, and speed.

The end result is your website will always be running, always be found, and always be able to help you conduct your business in a timely and efficient manner.

All it takes is a single click. From there, Checkbot does the rest, saving you valuable time.

With a user base of over 15,000 people and an average rating of 4.9 out of 5 on the Chrome Web Store, you can rest assured that Checkbot is a quality made product that elegantly does everything that it claims.

Here’s what you get:

  • Check hundreds of pages at once and identify fixes for SEO, speed, and security.
  • Scan your site for broken links, duplicate content, invalid HTML code, and more.
  • Test hundreds of pages at once with a single click.
  • Test local websites as you develop to stop website issues ever going live.
  • Easily share data and create reports by exporting URLs to CSV format.

Why spend hours diagnosing errors on your website when Checkbot can do that and more in an instant? Save 70 percent now and get it for only $29.99.

The AAPicks team writes about things we think you’ll like, and we may see a share of revenue from any purchases made through affiliate links. To see all our hottest deals, head over to the AAPICKS HUB. 

Source: Android Zone

The post Find website flaws fast and save 70% with Checkbot for Chrome appeared first on TuneMaster.ml.

7 best AMOLED-friendly dark mode apps on Android

AMOLED displays offer a host of advantages over LCD screens, but the biggest advantage has to be the deeper, richer blacks. This advantage also extends to apps with a dark mode, as we see some of them specifically offer an AMOLED-friendly dark mode that uses true blacks.

These modes are pretty handy if you want to save battery life or if you’re using the app in bed. So with that in mind, we take a look at the best dark mode apps with an AMOLED-friendly theme.


Pocket

Price: Free/$0.99 to $44.99 per item
DOWNLOAD ON GOOGLE PLAY
One of the most popular reading apps on the market, Pocket lets you save articles for offline viewing. Simply hit the Pocket button on your desktop browser or visit the sharing menu from your mobile browser to save an article. And sure enough, the app offers a toggle to use ‘true black’ for articles and the menus. So if you’d like to catch up on your reading list before bed, but don’t want to deal with glare, this should be up your alley.
DOWNLOAD ON GOOGLE PLAY
Pocket

Amazon Kindle

Price: Free
DOWNLOAD ON GOOGLE PLAY
Another reading app makes the list in Amazon’s Kindle app. The premise is pretty simple in case you haven’t heard, as you can buy and download millions of ebooks for use within the app. Its dark mode is unfortunately dark grey, so menus aren’t OLED-friendly. Thankfully, you can set ebook pages to a proper black color via the ‘Aa’ menu. Now, about bringing this option to the rest of the app…
DOWNLOAD ON GOOGLE PLAY
Amazon Kindle

Sync for Reddit

Price: Free/$1.99 to $3.99 per item
DOWNLOAD ON GOOGLE PLAY
One of the most popular third-party Reddit apps, Sync for Reddit was around long before the website decided to make its own official Android app. The app has a ton of features, ranging from multiple account support and offline synchronization to fully customizable themes. And yes, it’s one of the better dark mode apps thanks to the OLED-friendly black option. If that’s not enough, you can also make the navigation bar black.
DOWNLOAD ON GOOGLE PLAY
Sync for Reddit

Plume

Price: Free
DOWNLOAD ON GOOGLE PLAY
There are loads of solid Twitter apps out there, but Plume has the distinction of being one of the oldest clients on the Play Store. It supports all the expected Twitter features (DMs, likes, trends etc), but also serves up Facebook integration if that floats your boat. Otherwise, Plume delivers an eye-pleasing black mode for the timeline — hopefully they bring this mode to the rest of the app.
DOWNLOAD ON GOOGLE PLAY
Plume

Kiwi Browser

Price: Free
DOWNLOAD ON GOOGLE PLAY
There are several browsers out there with support for night modes, but the Chromium-based Kiwi is one of the better efforts out there. The app offers an OLED-friendly night mode out of the box, although most websites seem to take on a grey color instead of proper black like the browser UI. Other noteworthy features include ad-blocking, an address bar at the bottom of the app, and cryptojacking protection.
DOWNLOAD ON GOOGLE PLAY
Kiwi Browser

Gboard

Price: Free
DOWNLOAD ON GOOGLE PLAY
Google’s keyboard has quickly become a favorite among Android users since its release, offering GIF support, integrated Google search, and Google Translate functionality. Gboard also offers theme support, with one of these themes being a proper black theme. And with keyboards being a fixture in almost every app, this is definitely one of the first dark mode apps you should grab.
DOWNLOAD ON GOOGLE PLAY
Gboard

Pocket Casts

Price: $3.99
DOWNLOAD ON GOOGLE PLAY
This app has long been a fixture on Android smartphones, and for very good reason. Pocket Casts delivers an intuitive user interface, some useful features (trimming silence from podcasts, voice volume boost, custom skip intervals), and a dark theme. Well, technically speaking, you’ve got a dark theme and the OLED-friendly extra dark theme. The app also syncs your subscriptions to the cloud, so you can keep listening across iOS and your desktop.
DOWNLOAD ON GOOGLE PLAY
Pocket Casts

Know of any other AMOLED-friendly dark mode apps worth downloading? Then drop a comment below! You can also view more app lists right over here.

Source: Android Zone

The post 7 best AMOLED-friendly dark mode apps on Android appeared first on TuneMaster.ml.