Alarm manager in Android without pending intent

Alarm manager in Android without pending intent - android

I'm trying to create a method that will execute or run every 24 hours. What I exactly want to do is to delete the data from my database table "history" every day at 9am. I searched how to make this and I found an alarm manager but it works with PendingIntent. Is there any way to use alarm manager that handle a method instead of pending intent?

A PendingIntent is a token that you give to a foreign application (e.g. NotificationManager, AlarmManager, Home Screen AppWidgetManager, or other 3rd party applications), which allows the foreign application to use your application's permissions to execute a predefined piece of code.
If you give the foreign application an Intent, and that application sends/broadcasts the Intent you gave, they will execute the Intent with their own permissions. But if you instead give the foreign application a PendingIntent you created using your own permission, that application will execute the contained Intent using your application's permission.
So you can't use the AlaramManager without using the PendingIntent.

Related

creating a pending intent to start a non system app

I've read plenty of doc, but I still can't figure it out.
Are we allowed to start a 3rd party app(NON SYSTEM APP like as alarm, notification. etc) with a pending intent?
i.e.:
App1
create pending intent
start a non system app and send pending intent
App2
execute its own code
call pending intent to start App1
I haven't found 1 single example doing this. And according to the doc. you can pass a pending intent to a 3rd party app. It does not specify a system app
does it make sense?

Yes, you may launch anything you want with a PendingIntent. As long as the component you want to start is exported (publicly available).

Why do we use a pendingIntent to start a GeofenceTransitionIntentService?

I was going through the google docs for Geofencing and I have some doubts. They have used a pendingIntent to start the GeofenceTransitionIntentService. Can someone please explain why? Also when is the pendingIntent fired? Is it done when the user enters the geofence or as soon as the pendingIntent is created. Thanks in advance !!
From the android docs and my little understanding of pendingIntent I am not able to understand what is the foreign application here?
A PendingIntent is a token that you give to a foreign application
(e.g. NotificationManager , AlarmManager , Home Screen
AppWidgetManager , or other 3rd party applications), which allows the
foreign application to use your application's permissions to execute a
predefined piece of code.
Geofencing Docs

pending intent are not immediate, that's why why its called pending. just as in this paragraph.
A PendingIntent is a token that you give to a foreign application (e.g. NotificationManager , AlarmManager , Home Screen AppWidgetManager , or other 3rd party applications), which allows the foreign application to use your application's permissions to execute a predefined piece of code.
taking the NotificationManager as an example, its an external service or application. when creating a Notification using the NotificationManager class you pass a PendingIntent which links to an activity(or just say an application), this is the intent that will handle the notification. its just saying that the pendingIntent will link to an application that will handle to Notification when clicked.
same thing goes for the Geofencing, pendingIntent is pending(waiting) until an action that will trigger its to call the application that will execute the incoming event or data etc

Differences between Intent and PendingIntent

I read through some articles. All seem to do the same thing and I was wondering what is the difference between starting the service as below:
Intent intent = new Intent(this, HelloService.class);
startService(intent);
or below:
Calendar cal = Calendar.getInstance();
Intent intent = new Intent(this, MyService.class);
PendingIntent pintent = PendingIntent.getService(this, 0, intent, 0);
AlarmManager alarm = (AlarmManager)getSystemService(Context.ALARM_SERVICE);
alarm.setRepeating(AlarmManager.RTC_WAKEUP, cal.getTimeInMillis(), 30*1000, pintent);
As I read through, these two do the same thing, if in the service you return a parameter START_STICKY;

Intent
An Android Intent is an object carrying an intent, i.e. a message from one component to another component either inside or outside of the application. Intents can communicate messages among any of the three core components of an application -- Activities, Services, and BroadcastReceivers.
The intent itself, an Intent object, is a passive data structure. It holds an abstract description of an operation to be performed.
For example: say you have an Activity that needs to launch an email client and send an email. To do this, your Activity would send an Intent with the action ACTION_SEND, along with the appropriate chooser, to the Android Intent Resolver:
Intent intent = new Intent(Intent.ACTION_SENDTO);
intent.setData(Uri.parse("mailto:")); // only email apps should handle this
The specified chooser gives the proper interface for the user to pick how to send your email data.
EXPLICIT INTENTS
// Explicit Intent by specifying its class name
Intent i = new Intent(this, TargetActivity.class);
i.putExtra("Key1", "ABC");
i.putExtra("Key2", "123");
// Starts TargetActivity
startActivity(i);
IMPLICIT INTENTS
// Implicit Intent by specifying a URI
Intent i = new Intent(Intent.ACTION_VIEW,
Uri.parse("http://www.example.com"));
// Starts Implicit Activity
startActivity(i);
Pending Intent
A PendingIntent is a token that you give to a foreign application (e.g. NotificationManager, AlarmManager, Home Screen AppWidgetManager, or other 3rd party applications), which allows the foreign application to use your application's permissions to execute a predefined piece of code.
By giving a PendingIntent to another application, you are granting it
the right to perform the operation you have specified as if the other
application was yourself (with the same permissions and identity). As
such, you should be careful about how you build the PendingIntent:
almost always, for example, the base Intent you supply should have the
component name explicitly set to one of your own components, to ensure
it is ultimately sent there and nowhere else.
Example for Pending Intent : http://android-pending-intent.blogspot.in/
Source : Android Intents and Android Pending Intents

PendingIntent is a wrapper of Intent. The foreign app that receives the PendingIntent, doesn't know the content of Intent which is wrapped by PendingIntent. The mission of foreign app is to send back the intent to owner when some conditions are met (For example: alarm with schedule, or notification with click...). The conditions are given by owner but processed by foreign app (For example: alarm, notification).
If foreign app sent intent to your app, mean that foreign app know about the content of the intent. and foreign app make decision to send intent then your app must process intent to meet some conditions => your app get performance resource of system.

Another simple difference:
Normal intent will die as soon as the app is killed.
Pending intents never die. They will be alive as long as it's needed by alarm service, location service, or any other services.

There's another major difference between Intent and PendingIntent which is better to be aware of, otherwise your app's design might become vulnerable. The problem is well described in Android Nesting Intents article.
Note that PendingIntent.send() method doesn't accept a Context instance, it uses a context provided during the intent creation instead. It allows a third party component to execute an action associated with a pending intent within the intent creator's context.
Let's imagine a third party service which performs some job and then starts an activity specified by your app as an intent. If the callback activity is provided as a basic Intent, the service can only start it using its own context and such a design has two drawbacks:
It forces the callback activity to be defined as exported so it can be started using a third party context. As a result the activity can be started not only by the service it was intended for, but by any other app installed on the device.
Any activity defined by the third party service app can be used as a callback activity, even non-exported one, since it's started using the third party context.
Both problems can be easily solved by specifying the callback activity as PendingIntent instead.

Functionally, there is no difference.
The meaning of PendingIntent is that, you can handle it to other application that later can use it as if the other application was yourself. Here is the relevant explanation from the documentation:
By giving a PendingIntent to another application, you are granting it
the right to perform the operation you have specified as if the other
application was yourself (with the same permissions and identity). As
such, you should be careful about how you build the PendingIntent:
almost always, for example, the base Intent you supply should have the
component name explicitly set to one of your own components, to ensure
it is ultimately sent there and nowhere else.
A PendingIntent itself is simply a reference to a token maintained by
the system describing the original data used to retrieve it.
So PendingIntent is just a reference to the data that represents the original Intent (that used to create the PendingIntent).

Starting services regularly via AlarmManager
As with activities the Android system may terminate the process of a service at any time to save resources. For this reason you cannot simply use a TimerTask in the service to ensure that it is executed on a regular basis.
So, for correct scheduling of the Service use the AlarmManager class.
UPDATE:
So there is no actual difference between the two.
But depending on whether you want to ensure the execution of the service or not, you can decide what to use as for the former there is no guarantee and for the later it is.
More info at AndroidServices.

what is the exact difference between intent and pending intent? [duplicate]

I read the Android Documentation but I still need some more clarification. What exactly is a PendingIntent?

A PendingIntent is a token that you give to a foreign application (e.g. NotificationManager, AlarmManager, Home Screen AppWidgetManager, or other 3rd party applications), which allows the foreign application to use your application's permissions to execute a predefined piece of code.
If you give the foreign application an Intent, it will execute your Intent with its own permissions. But if you give the foreign application a PendingIntent, that application will execute your Intent using your application's permission.

Why PendingIntent is required ? I was thinking like
Why the receiving application itself cannot create the Intent or
Why we cannot use a simple Intent for the same purpose.
E.g.Intent bluetoothIntent= new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
If I send bluetoothIntent to another application, which doesn't have permission android.permission.BLUETOOTH_ADMIN, that receiving application cannot enable Bluetooth with startActivity(bluetoothIntent).
The limitation is overcome using PendingIntent. With PendingIntent the receiving application, doesn't need to have android.permission.BLUETOOTH_ADMIN for enabling Bluetooth. Source.

A Pending Intent is a token you give to some app to perform an action on your apps' behalf irrespective of whether your application process is alive or not.
I think the documentation is sufficiently detailed:
Pending Intent docs.
Just think of use-cases for Pending Intents like (Broadcasting Intents, scheduling alarms) and the documentation will become clearer and meaningful.

In my case, none of above answers nor google's official documentation helped me to grab the concept of PendingIntent class.
And then I found this video, Google I/O 2013, Beyond the Blue Dot session. In this video, ex-googler Jaikumar Ganesh explains what PendingIntent is, and that was the thing gave me the big picture of this.
Below is just transcription of above video (from 15:24).
So what's a pending intent?
It's a token that your app process will give to the location process, and the location process will use it to wake up your app when an event of interest happens. So this basically means that your app in the background doesn't have to be always running. When something of interest happens, we will wake you up. This saves a lot of battery.
This explanation becomes more clear with this snippet of code(which is included in the session's slide).
PendingIntent mIntent = PendingIntent.getService(...);
mLocationClient.requestLocationUpdates(locationRequest, mIntent);
public void onHandleIntent(Intent intent) {
String action = intent.getAction();
if (ACTION_LOCATION.equals(action)) {
Location location = intent.getParcelableExtra(...)
}
}

Pending intent is an intent which will start at some point in the future. Normal intent starts immediately when it is passed to startActivity(Intent) or StartService(Intent).

TAXI ANALOGY
Intent
Intents are typically used for starting Services. For example:
Intent intent = new Intent(CurrentClass.this, ServiceClass.class);
startService(intent);
This is like when you call for a taxi:
Myself = CurrentClass
Taxi Driver = ServiceClass
Pending Intent
You will need to use something like this:
Intent intent = new Intent(CurrentClass.this, ServiceClass.class);
PendingIntent pi = PendingIntent.getService(parameter, parameter, intent, parameter);
getDataFromThirdParty(parameter, parameter, pi, parameter);
Now this Third party will start the service acting on your behalf.
A real life analogy is Uber or Lyft who are both taxi companies.
You send a request for a ride to Uber/Lyft. They will then go ahead and call one of their drivers on your behalf.
Therefore:
Uber/Lyft ------ ThirdParty which receives PendingIntent
Myself --------- Class calling PendingIntent
Taxi Driver ---- ServiceClass

What is an Intent?
An Intent is a specific command in Android that allows you to send a command to the Android OS to do something specific. Think of it as an action that needs to take place. There are many actions that can be done such as sending an email, or attaching a photo to an email, or even launching an application.
The logical workflow of creating an intent is usually as follows:
a. Create the Intent
b. Add Intent options -> Ex. what type of intent we are sending to the OS or any attributes associated with that intent, such as a text string or something being passed along with the intent
c. RUN the Intent
Real-Life Example: Let's say I wake up in the morning and I "INTEND" to go to the washroom. I will first have to THINK about going to the washroom, but that DOESN'T really gets me to the washroom. I will then have to tell my brain to get out of bed first, then walk to the washroom, and then release, then go and wash my hands, then go and wipe my hands. Once I know where I'm going I SEND the command to begin and my body takes action.
What is Pending Intents?
Continuing from the real-life example, let's say I want to take a shower but I want to shower AFTER I brush my teeth and eat breakfast. So I know I won't be showering until at least 30-40 minutes. I still have in my head that I need to prepare my clothes, and then walk up the stairs back to the bathroom, then undress and then shower. However, this will not happen until 30-40 minutes have passed. I now have a PENDING intent to shower. It is PENDING for 30-40 minutes.
That is pretty much the difference between a Pending Intent and a Regular Intent. Regular Intents can be created without a Pending Intent, however, in order to create a Pending Intent you need to have a Regular Intent setup first.

A future intent that other apps can use.
And here's an example for creating one:
Intent intent = new Intent(context, MainActivity.class);
PendingIntent pendIntent = PendingIntent.getActivity(context, 0, intent, 0);

A PendingIntent is a token that you give to another application (e.g. Notification Manager, Alarm Manager or other 3rd party applications), which allows this other application to use the permissions of your application to execute a predefined piece of code.
To perform a broadcast via a pending intent so get a PendingIntent via PendingIntent.getBroadcast(). To perform an activity via an pending intent you receive the activity via PendingIntent.getActivity().

PendingIntent is basically an object that wraps another Intent object. Then it can be passed to a foreign application where you’re granting that app the right to perform the operation, i.e., execute the intent as if it were executed from your own app’s process (same permission and identity). For security reasons you should always pass explicit intents to a PendingIntent rather than being implicit.
PendingIntent aPendingIntent = PendingIntent.getService(Context, 0, aIntent,
PendingIntent.FLAG_CANCEL_CURRENT);

A PendingIntent wraps the general Intent with a token that you give to foreign app to execute with your permission.
For eg:
The notification of your music app can't play/pause the music if you
didn't give the PendingIntent to send broadcast because your music app
has READ_EXTERNAL_STORAGE permission which the notification app
doesn't. Notification is a system service (so it's a foreign app).

A Pending Intent specifies an action to take in the future. It lets you pass a future Intent to another application and allow that application to execute that Intent as if it had the same permissions as your application, whether or not your application is still around when the Intent is eventually invoked.
It is a token that you give to a foreign application which allows the foreign application to use your application’s permissions to execute a predefined piece of code.
If you give the foreign application an Intent, and that application sends/broadcasts the Intent you gave, they will execute the Intent with their own permissions. But if you instead give the foreign application a Pending Intent you created using your own permission, that application will execute the contained Intent using your application’s permission.
To perform a broadcast via a pending intent so get a PendingIntent via PendingIntent.getBroadcast(). To perform an activity via an pending intent you receive the activity via PendingIntent.getActivity().
It is an Intent action that you want to perform, but at a later time. Think of it a putting an Intent on ice. The reason it’s needed is because an Intent must be created and launched from a valid Context in your application, but there are certain cases where one is not available at the time you want to run the action because you are technically outside the application’s context (the two common examples are launching an Activity from a Notification or a BroadcastReceiver.
By creating a PendingIntent you want to use to launch, say, an Activity while you have the Context to do so (from inside another Activity or Service) you can pass that object around to something external in order for it to launch part of your application on your behalf.
A PendingIntent provides a means for applications to work, even after their process exits. Its important to note that even after the application that created the PendingIntent has been killed, that Intent can still run. A description of an Intent and target action to perform with it. Instances of this class are created with getActivity(Context, int, Intent, int), getBroadcast(Context, int, Intent, int), getService (Context, int, Intent, int); the returned object can be handed to other applications so that they can perform the action you described on your behalf at a later time.
By giving a PendingIntent to another application, you are granting it the right to perform the operation you have specified as if the other application was yourself (with the same permissions and identity). As such, you should be careful about how you build the PendingIntent: often, for example, the base Intent you supply will have the component name explicitly set to one of your own components, to ensure it is ultimately sent there and nowhere else.
A PendingIntent itself is simply a reference to a token maintained by the system describing the original data used to retrieve it. This means that, even if its owning application’s process is killed, the PendingIntent itself will remain usable from other processes that have been given it. If the creating application later re-retrieves the same kind of PendingIntent (same operation, same Intent action, data, categories, and components, and same flags), it will receive a PendingIntent representing the same token if that is still valid, and can thus call cancel() to remove it.

In an easy language,
1. A description of an Intent and Target action to perform. First you have to create an intent and then you have to pass an specific java class which you want to execute, to the Intent.
2. You can call those java class which is your class action class by PendingIntent.getActivity, PendingIntent.getActivities(Context, int, Intent[], int), PendingIntent.getBroadcast(Context, int, Intent, int), and PendingIntent.getService(Context, int, Intent, int);
Here you see that Intent which is comes from the step 1
3. You should keep in mind that...By giving a PendingIntent to another application, you are granting it the right to perform the operation you have specified.
That is what I learned after a long reading.

In simple terms
A pending intent is basically an intent that you can pass to other apps or services like notification manager, alarm manager etc. and let them handle when is the right timing/behaviour for it to be executed.

As its name suggest .. PendingIntent
you can pend(do it after some time) it . It work as the other intent ..it is a way of giving your task to some other app to perform on your behalf.

Pending Intent
A pending intent is a wrapper around regular intent that is designed
to be used by another application.
It gives that other application the ability to perform the included
action as it was your application with all the permissions your
application has been granted
When you want to open some application components like Activity/Service/BroadcastReceiver at later time or after some specified time interval you have to send PendingIntent in this case. It acts like a permission slip you gave to another apps to run your application’s code on your behalf after some time. So PendingIntent works beyond process boundaries like you want AlarmManager which is an another app in another process then AlarmManager perfom action on your app specified by PendingIntent

Pending Intent is an intent who provides all permission to other application to do a particular works. When the main activity is destroyed, Android OS takes back the permission from it.

I have came across PendingIntents in Notifications. So here is a simple explanation:
We want to provide an Intent to Notification, in this case we want to open a Activity which performs Camera capture functionality. Here, if we pass simply Intent, the NotificationManager doesnt have this permission although my app has this permission stated in Manifest; due to this the action wont work as NotificationManager doesnt have the permission to do so.
But, if you use PendingIntent, here the permission that my app have will be used instead of NotificationManager. Therefore, even if NotificationManager doesnt have Camera permission and my app has it will still open up the activity and perform the app.
NOTE: Pending intent requires regular Intent to be setup first.

What is an Android PendingIntent?

I read the Android Documentation but I still need some more clarification. What exactly is a PendingIntent?

A PendingIntent is a token that you give to a foreign application (e.g. NotificationManager, AlarmManager, Home Screen AppWidgetManager, or other 3rd party applications), which allows the foreign application to use your application's permissions to execute a predefined piece of code.
If you give the foreign application an Intent, it will execute your Intent with its own permissions. But if you give the foreign application a PendingIntent, that application will execute your Intent using your application's permission.

Why PendingIntent is required ? I was thinking like
Why the receiving application itself cannot create the Intent or
Why we cannot use a simple Intent for the same purpose.
E.g.Intent bluetoothIntent= new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
If I send bluetoothIntent to another application, which doesn't have permission android.permission.BLUETOOTH_ADMIN, that receiving application cannot enable Bluetooth with startActivity(bluetoothIntent).
The limitation is overcome using PendingIntent. With PendingIntent the receiving application, doesn't need to have android.permission.BLUETOOTH_ADMIN for enabling Bluetooth. Source.

A Pending Intent is a token you give to some app to perform an action on your apps' behalf irrespective of whether your application process is alive or not.
I think the documentation is sufficiently detailed:
Pending Intent docs.
Just think of use-cases for Pending Intents like (Broadcasting Intents, scheduling alarms) and the documentation will become clearer and meaningful.

In my case, none of above answers nor google's official documentation helped me to grab the concept of PendingIntent class.
And then I found this video, Google I/O 2013, Beyond the Blue Dot session. In this video, ex-googler Jaikumar Ganesh explains what PendingIntent is, and that was the thing gave me the big picture of this.
Below is just transcription of above video (from 15:24).
So what's a pending intent?
It's a token that your app process will give to the location process, and the location process will use it to wake up your app when an event of interest happens. So this basically means that your app in the background doesn't have to be always running. When something of interest happens, we will wake you up. This saves a lot of battery.
This explanation becomes more clear with this snippet of code(which is included in the session's slide).
PendingIntent mIntent = PendingIntent.getService(...);
mLocationClient.requestLocationUpdates(locationRequest, mIntent);
public void onHandleIntent(Intent intent) {
String action = intent.getAction();
if (ACTION_LOCATION.equals(action)) {
Location location = intent.getParcelableExtra(...)
}
}

Pending intent is an intent which will start at some point in the future. Normal intent starts immediately when it is passed to startActivity(Intent) or StartService(Intent).

TAXI ANALOGY
Intent
Intents are typically used for starting Services. For example:
Intent intent = new Intent(CurrentClass.this, ServiceClass.class);
startService(intent);
This is like when you call for a taxi:
Myself = CurrentClass
Taxi Driver = ServiceClass
Pending Intent
You will need to use something like this:
Intent intent = new Intent(CurrentClass.this, ServiceClass.class);
PendingIntent pi = PendingIntent.getService(parameter, parameter, intent, parameter);
getDataFromThirdParty(parameter, parameter, pi, parameter);
Now this Third party will start the service acting on your behalf.
A real life analogy is Uber or Lyft who are both taxi companies.
You send a request for a ride to Uber/Lyft. They will then go ahead and call one of their drivers on your behalf.
Therefore:
Uber/Lyft ------ ThirdParty which receives PendingIntent
Myself --------- Class calling PendingIntent
Taxi Driver ---- ServiceClass

A future intent that other apps can use.
And here's an example for creating one:
Intent intent = new Intent(context, MainActivity.class);
PendingIntent pendIntent = PendingIntent.getActivity(context, 0, intent, 0);

A PendingIntent is a token that you give to another application (e.g. Notification Manager, Alarm Manager or other 3rd party applications), which allows this other application to use the permissions of your application to execute a predefined piece of code.
To perform a broadcast via a pending intent so get a PendingIntent via PendingIntent.getBroadcast(). To perform an activity via an pending intent you receive the activity via PendingIntent.getActivity().

PendingIntent is basically an object that wraps another Intent object. Then it can be passed to a foreign application where you’re granting that app the right to perform the operation, i.e., execute the intent as if it were executed from your own app’s process (same permission and identity). For security reasons you should always pass explicit intents to a PendingIntent rather than being implicit.
PendingIntent aPendingIntent = PendingIntent.getService(Context, 0, aIntent,
PendingIntent.FLAG_CANCEL_CURRENT);

A PendingIntent wraps the general Intent with a token that you give to foreign app to execute with your permission.
For eg:
The notification of your music app can't play/pause the music if you
didn't give the PendingIntent to send broadcast because your music app
has READ_EXTERNAL_STORAGE permission which the notification app
doesn't. Notification is a system service (so it's a foreign app).

In an easy language,
1. A description of an Intent and Target action to perform. First you have to create an intent and then you have to pass an specific java class which you want to execute, to the Intent.
2. You can call those java class which is your class action class by PendingIntent.getActivity, PendingIntent.getActivities(Context, int, Intent[], int), PendingIntent.getBroadcast(Context, int, Intent, int), and PendingIntent.getService(Context, int, Intent, int);
Here you see that Intent which is comes from the step 1
3. You should keep in mind that...By giving a PendingIntent to another application, you are granting it the right to perform the operation you have specified.
That is what I learned after a long reading.

In simple terms
A pending intent is basically an intent that you can pass to other apps or services like notification manager, alarm manager etc. and let them handle when is the right timing/behaviour for it to be executed.

As its name suggest .. PendingIntent
you can pend(do it after some time) it . It work as the other intent ..it is a way of giving your task to some other app to perform on your behalf.

Pending Intent
A pending intent is a wrapper around regular intent that is designed
to be used by another application.
It gives that other application the ability to perform the included
action as it was your application with all the permissions your
application has been granted
When you want to open some application components like Activity/Service/BroadcastReceiver at later time or after some specified time interval you have to send PendingIntent in this case. It acts like a permission slip you gave to another apps to run your application’s code on your behalf after some time. So PendingIntent works beyond process boundaries like you want AlarmManager which is an another app in another process then AlarmManager perfom action on your app specified by PendingIntent

Pending Intent is an intent who provides all permission to other application to do a particular works. When the main activity is destroyed, Android OS takes back the permission from it.

I have came across PendingIntents in Notifications. So here is a simple explanation:
We want to provide an Intent to Notification, in this case we want to open a Activity which performs Camera capture functionality. Here, if we pass simply Intent, the NotificationManager doesnt have this permission although my app has this permission stated in Manifest; due to this the action wont work as NotificationManager doesnt have the permission to do so.
But, if you use PendingIntent, here the permission that my app have will be used instead of NotificationManager. Therefore, even if NotificationManager doesnt have Camera permission and my app has it will still open up the activity and perform the app.
NOTE: Pending intent requires regular Intent to be setup first.

Develop Reference

The Android operating system is a mobile operating system that was developed by Google (GOOGL?) to be primarily used for touchscreen devices, cell phones, and tablets.