I want to implement this scenario for my application. I want to schedule my service to start when the phone boots, and whenever another application calls my service I want my service to start a certain activity within the project.
So in order to be clear. I want to create a project which contains a service which runs whenever the phone boots, and is dormant, listening for a call from a third party application. And whenever that call is received this service calls an Activity (from the same project, not third party)
How can I configure my manifest file in order to achieve this?
I have also come across this suggestion but my scenario is pretty different.
Thank you very much in advance
**Define Service in manifest and Create the BroadcastReciever with boot complete permission and listen the intent.If boot completed start the service.**
public class MyService extends Service {
Context context = this;
#Nullable
#Override
public IBinder onBind(Intent intent) {
return null;
}
#Override
public int onStartCommand(Intent intent, int flags, int startId) {
try {
Intent activity = new Intent(context, MyActivity.class);
activity.putExtra("Message", "fromService");
activity.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
activity.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
context.startActivity(activity );
} catch (Exception e) {
MyLog.printException(e);
}
return super.onStartCommand(intent, flags, startId);
}
}
By creating a BroadcastReceiver you can perform the service startup.
public class StartupReceiver extends BroadcastReceiver {
#Override
public void onReceive(Context context, Intent intent) {
if (intent.getAction().equals(Intent.ACTION_BOOT_COMPLETED)) {
Intent i = new Intent(context, ShowActivity.class);
i.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
context.startActivity(i);
}
}
}
and in the manifest
<receiver
android:name=".StartupReceiver"
android:enabled="true"
android:exported="true"
android:permission="android.permission.RECEIVE_BOOT_COMPLETED">
<intent-filter>
<action android:name="android.intent.action.BOOT_COMPLETED" />
<action android:name="android.intent.action.QUICKBOOT_POWERON" />
<category android:name="android.intent.category.DEFAULT" />
</intent-filter>
</receiver>
This allows you to run an Activity, you can then start a Foreground Service from that activity. I just set this example because I have it ready, you can adapt it to run a service as you like.
Related
I want to make two android services that kip running on background even when my app is closed or when all system reboots, but I have no idea about android. And that's what I did:
AndroidManifest.xml
<uses-permission android:name="android.permission.RECEIVE_ROOT_COMPLETED"/>
<service android:name="FirstService"></service>
<receiver android:name="FirstServiceReceiver">
<intent-filter>
<action android:name="com.android.techrainner"/>
<action android:name="android.intent.action.BOOT_COMPLETED" />
</intent-filter>
</receiver>
<service android:name="SecondService"></service>
<receiver android:name="SecondServiceReceiver">
<intent-filter>
<action android:name="com.android.techrainner"/>
<action android:name="android.intent.action.BOOT_COMPLETED" />
</intent-filter>
</receiver>
this my MainActivity (WL : because I am using IBM MobileFirst)
public void onCreate(Bundle savedInstanceState){
super.onCreate(savedInstanceState);
WL.createInstance(this);
WL.getInstance().showSplashScreen(this);
WL.getInstance().initializeWebFramework(getApplicationContext(), this);
Intent startFirstServiceIntent = new Intent(this,FirstService.class);
Intent startSecondServiceIntent = new Intent(this,SecondService.class);
startService(startFirstServiceIntent);
startService(startSecondServiceIntent);
}
this is the first service :
class FirstService extends Service {
#Override
public IBinder onBind(Intent arg0) {
// TODO Auto-generated method stub
return null;
}
#Override
public int onStartCommand(Intent intent,int flags,int startId){
return START_STICKY;
}
}
the second service is the same as the first
the first receiver :
public class FirstServiceReceiver extends BroadcastReceiver {
#Override
public void onReceive(Context context, Intent intent) {
context.startService(new Intent(context,FirstService.class));
}
}
Also the second receiver is the same as the first.
Two services are running on background only when the app is opened, and they will be stopped when I close it.
As in Android documentation, it is written about Service as:
A service is "started" when an application component (such as an activity) starts it by calling startService(). Once started, a service can run in the background indefinitely, even if the component that started it is destroyed. Usually, a started service performs a single operation and does not return a result to the caller. For example, it might download or upload a file over the network. When the operation is done, the service should stop itself.
So when operation is done Service stops automatically. If you want to start your service even your app gets destroyed then you can use Alarm Manager Service. You can set a repeating alarm in your application to start your service in background.
And if your requirement is to sync your app with your app server and want to sync with server even your app is closed then you can use SyncAdapter Framework of Android.
Im trying to track how many times the "SCREEN_ON" is triggered without the user starting the app. The app itself shows a single activity with some charts and info nothing more. I created a small test but i think it's not the correct way because it's draining my battery.
I got a broadcast receiver "BOOT_COMPLETED" that starts a sticky IntentService that is registering the "SCREEN_ON" broadcast receiver with a never ending loop to catch to broadcast's (the battery drain problem).
Is it possible that i can listen on the "SCREEN_ON" broadcast without a Service?
Jur
Manifest
<manifest xmlns:android="http://schemas.android.com/apk/res/android">
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
<application
android:name=".Application"
android:allowBackup="true"
android:icon="#mipmap/ic_launcher"
android:label="#string/app_name"
android:theme="#style/AppTheme"
android:hardwareAccelerated="true">
<activity
android:name=".activities.MainActivity"
android:label="#string/app_name" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<service android:enabled="true" android:name=".services.ScreenOnService" />
<receiver android:name=".broadcast.receivers.AutoStartReceiver">
<intent-filter>
<action android:name="android.intent.action.BOOT_COMPLETED" />
</intent-filter>
</receiver>
<receiver android:name=".broadcast.receivers.ScreenOnReceiver">
<intent-filter>
<action android:name="android.intent.action.SCREEN_ON" />
</intent-filter>
</receiver>
</application>
AutoStartReceiver
public class AutoStartReceiver extends BroadcastReceiver
{
public void onReceive(Context aContext, Intent anIntent)
{
Log.i("[AutoStartReceiver]", "onReceive");
aContext.startService(new Intent(aContext, ScreenOnService.class));
}
}
ScreenOnReceiver
public class ScreenOnReceiver extends BroadcastReceiver
{
#Override
public void onReceive(Context context, Intent intent)
{
Log.i("[ScreenOnReceiver]", "onReceive");
}
}
ScreenOnService
public class ScreenOnService extends IntentService
{
private ScreenOnReceiver theReceiver;
public ScreenOnService()
{
super(ScreenOnService.class.getName());
theReceiver = new ScreenOnReceiver();
}
#Override
public int onStartCommand(Intent intent, int flags, int startId)
{
Log.v("[ScreenOnService]", "onStartCommand");
super.onStartCommand(intent, flags, startId);
return START_STICKY;
}
#Override
protected void onHandleIntent(Intent intent)
{
Log.i("[ScreenOnService]", "onHandleIntent");
registerReceiver(theReceiver, new IntentFilter(Intent.ACTION_SCREEN_ON));
while(true);
}
#Override
public void onDestroy()
{
Log.i("[ScreenOnService]", "onDestroy");
unregisterReceiver(theReceiver);
super.onDestroy();
}
}
Do you have any particular reason for using an IntentService as opposed to a regular started Service?
You should be able to achieve this using a regular started Service. Register the receiver as part of onStartCommand.
Something like this:
public class MyService extends Service {
private ScreenOnReceiver mReceiver;
#Override
public int onStartCommand(Intent intent, int flags, int startId) {
if (mReceiver == null) {
mReceiver = new ScreenOnReceiver();
registerReceiver(mReceiver, new IntentFilter(Intent.ACTION_SCREEN_ON));
}
// We want this service to continue running until it is explicitly
// stopped, so return sticky.
return START_STICKY;
}
// remember to unregister receiver in onDestroy...
}
This way you avoid busy looping. IntentService is designed to be a short lived service performing a background operation. Your usage does not fit the purpose of IntentService.
I got a broadcast receiver "BOOT_COMPLETED" that starts a sticky IntentService that is registering the "SCREEN_ON" broadcast receiver with a never ending loop to catch to broadcast's (the battery drain problem)
This is completely inappropriate for an IntentService. Your problem is that an IntentService shuts down after onHandleIntent() returns, forcing you into this busy-wait.
Instead, use a regular Service.
Is it possible that i can listen on the "SCREEN_ON" broadcast without a Service?
AFAIK, ACTION_SCREEN_ON still cannot be registered for in the manifest, so, yes, you need a Service. But you need a Service, not an IntentService.
I got a broadcast receiver "BOOT_COMPLETED" that starts a sticky
IntentService that is registering the "SCREEN_ON" broadcast receiver
with a never ending loop to catch to broadcast's (the battery drain
problem).
This is not correct. The intent service is not design for long running operation.Actually It is no longer remain running after onHandleIntent().
If you want to listen constantly up to device is turn on then service will sure help you to listen each every trigger.
public class ScreenOnService extends Service
{
...........
}
My target Android is 4.1.2. I created an simple android service which will show Toast on boot. But this application should not have any GUI. I was success running this service only from an activity which show GUI on start.
public class MyServices extends Service {
private MediaRecorder recorder = null;
#Override
public IBinder onBind(Intent intent) {
return null;
}
public int onStartCommand(Intent intent, int flags, int StartId)
{
Toast.makeText(this, "Service Started", Toast.LENGTH_LONG).show();
}
}
You can start this service from RebootReceiver but As of Android 3.0 the user needs to have started the application at least once before your application can receive android.intent.action.BOOT_COMPLETED events.
Reboot Receiver -> Android BroadcastReceiver on startup - keep running when Activity is in Background
First you have to create a receiver:
public class BootCompletedReceiver extends BroadcastReceiver {
final static String TAG = "BootCompletedReceiver";
#Override
public void onReceive(Context context, Intent arg1) {
Log.w(TAG, "starting service...");
context.startService(new Intent(context, MyServices.class));
}
}
Then add permission to your AndroidManifest.xml
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
and register intent receiver:
<receiver android:name=".BootCompletedReceiver" >
<intent-filter>
<action android:name="android.intent.action.BOOT_COMPLETED" />
</intent-filter>
After this is done, your application (Application class) will run along with services, but no Activities, don't put your application on SD card (APP2SD or something like that), because it has to reside in the main memory to be available right after the boot is completed.
i am beginner at android. I have two class, and first class is
public class SmsReceiver extends BroadcastReceiver{}
And the second class is
public class SMS extends Activity{}
All I want to do that : when I get an SMS, start activity and do something. But i want to use "service" instead of "activity". I mean when application start, then start service without activity.
is this possible ?
Start your Service from SmsReceiver as:
public class SmsReceiver extends BroadcastReceiver{
#Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if(action.equals("android.provider.Telephony.SMS_RECEIVED")){
//action for sms received
// start service here
Intent intent=new Intent(context,Your_Service.class);
context.startService(intent);
}
else {
}
}
}
and make sure you have registered your service in AndroidManifest.xml as :
<service android:name="com.xxx.xx.Your_Service" />
Yes you can do that by just creating a BroadCastReceiver that calls your Service when your Application Boots. Here is a complete answer given by me. Android - Start service on boot
If you don't want any icon/launcher for you Application you can do that also, just don't create any Activity with
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
Just declare your Service as declared normally.
When you got an sms you can start your service by broadcast receiver
#Override
public void onReceive(Context context, Intent intent) {
try {
context.startService(new Intent(context,
YourService.class));
} catch (Exception e) {
Log.d("Unable to start ", "Service on ");
}
and pls make sure you have mention the permission to your AndroidManifest.xml file
<uses-permission android:name="android.permission.RECEIVE_SMS">
and for sms sending and receiving you can check out this tutorial Sending sms in android
I want to put up a notification in the notification bar that will launch my app when pressed. While I have no problems doing this, my users want the notification to come up after a reboot as well. They have an app from another vendor that does this.
Everything I can find states that the app must be running for the notification to display. Any ideas?
You need to add a receiver that launches a Service after a reboot.
In your manifest register for Boot Complete
<service android:name="com.meCorp.service.MeCorpServiceClass"/>
...
<receiver android:name="com.meCorp.receiver.MyRebootReceiver">
<intent-filter>
<action android:name="android.intent.action.BOOT_COMPLETED"/>
</intent-filter>
</receiver>
...
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
In your boot receiver, launch a service.
public class MyRebootReceiver extends BroadcastReceiver {
#Override
public void onReceive(Context context, Intent intent) {
Intent serviceIntent = new Intent(context, MeCorpServiceClass.class);
serviceIntent.putExtra("caller", "RebootReceiver");
context.startService(serviceIntent);
}
}
Here is an example for a service class to run in the background.
public class MeCorpServiceClass extends IntentService{
#Override
protected void onHandleIntent(Intent intent){
String intentType = intent.getExtras().getString("caller");
if(intentType == null) return;
if(intentType.Equals("RebootReceiver"))
//Do reboot stuff
//handle other types of callers, like a notification.
}
}
OR Just use a third party like Urban AirShip, which handles all that for you.