Question

在我的应用程序中，我启动了一项服务，以便在应用程序处于后台时接收通知 - 此服务会强制我的应用程序在我停止后自动启动。我试图通过使用挂起的意图解决问题，但它仍然发生。

我打算开始这项服务：

Intent messageReceivingIntent = new Intent(this, MessageReceivingService.class);
messageReceivingIntent.putExtra("myUserId", myUserId);
Pending Inten messagePendingIntent = PendingIntent.getService(this, 0, messageReceivingIntent, PendingIntent.FLAG_UPDATE_CURRENT);

    try {
        // Perform the operation associated with our pendingIntent
        messagePendingIntent.send();
    } catch (PendingIntent.CanceledException e) {
        e.printStackTrace();
    }

如果我通过externalreceiver调用服务，我会得到一个nullpointerexception。任何想法为什么？

这是我的BroadcastReceiver电话：

messageReceivingIntent = new Intent(this, MessageReceivingService.class);
messageReceivingIntent.putExtra("myUserId", myUserId);
messageReceivingIntent.setAction("com.example.androidtest");
sendBroadcast(messageReceivingIntent);

这是我的广播接收器：

public class ExternalReceiver extends BroadcastReceiver {

@Override
public void onReceive(Context context, Intent intent) {
    if(intent!=null){
        Bundle extras = intent.getExtras();
        if(!MapsActivity.inBackground){
            MessageReceivingService.sendToApp(extras, context);
        }
        else{
            MessageReceivingService.saveToLog(extras, context);
        }
    }
}

}

这是MessageReceivingService

public class MessageReceivingService extends Service {
private GoogleCloudMessaging gcm;
public static SharedPreferences savedValues;

public static final String INSTANCE_ID_SCOPE = "GCM";
final String BASE_URL = "http://www.example.com/";

public String myUserId;
public String registeredUserId;
public String token;
static PendingIntent pendingIntent;


public static void sendToApp(Bundle extras, Context context) {
    Intent newIntent = new Intent();
    newIntent.setClass(context, MapsActivity.class);
    newIntent.putExtras(extras);

    ShortcutBadger.applyCount(Content.getAppContext(), 0);

    newIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    context.startActivity(newIntent);
}

public void onCreate() {
    super.onCreate();
    final String preferences = getString(R.string.preferences);
    savedValues = getSharedPreferences(preferences, Context.MODE_PRIVATE);
    // In later versions multi_process is no longer the default
    if (VERSION.SDK_INT > 9) {
        savedValues = getSharedPreferences(preferences, Context.MODE_MULTI_PROCESS);
    }
    gcm = GoogleCloudMessaging.getInstance(getBaseContext());






    // Let AndroidMobilePushApp know we have just initialized and there may be stored messages
    sendToApp(new Bundle(), this);
}

protected static void saveToLog(Bundle extras, Context context) {
    SharedPreferences.Editor editor = savedValues.edit();
    String numOfMissedMessages = context.getString(R.string.num_of_missed_messages);
    int linesOfMessageCount = 0;

    for (String key : extras.keySet()) {
        String line = String.format("%s=%s", key, extras.getString(key));
        editor.putString(key, line);
        linesOfMessageCount++;
    }
    editor.putInt(context.getString(R.string.lines_of_message_count), linesOfMessageCount);
    editor.putInt(context.getString(R.string.lines_of_message_count), linesOfMessageCount);
    editor.putInt(numOfMissedMessages, savedValues.getInt(numOfMissedMessages, 0) + 1);
    editor.commit();

    String type = extras.getString("model");
    String id = extras.getString("id");
    String userId = extras.getString("user_id");

    //postNotification(new Intent(context, MapsActivity.class), context);
    if(type != null) {
        if (type.equals("content")) {
            Intent contentIntent = new Intent(context, ContentDetailActivity.class);

            Log.v("userID", userId);

            contentIntent.putExtra("contentId", id);
            if (userId != null) {
                contentIntent.putExtra("userId", userId);
            }

            postNotification(contentIntent, context);
        } else if (type.equals("user")) {
            Intent userIntent = new Intent(context, ProfileActivity.class);
            userIntent.putExtra("userId", id);

            postNotification(userIntent, context);
        }
    } else {
        postNotification(new Intent(context, NotificationsActivity.class), context);
    }

    ShortcutBadger.applyCount(Content.getAppContext(), Integer.valueOf(savedValues.getInt(Content.getAppContext().getString(R.string.num_of_missed_messages), 0)));
}

protected static void postNotification(Intent intentAction, Context context) {
    final NotificationManager mNotificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);

    pendingIntent = PendingIntent.getActivity(context, 0, intentAction, PendingIntent.FLAG_UPDATE_CURRENT);

    int numOfMissedMessages = 0;
    String missedMessage = "";
    if(savedValues != null){
        missedMessage = savedValues.getString("message", "nothing there");
    }



    Log.v("NUMOFMISSEDMESSAGES", String.valueOf(numOfMissedMessages));

    final Notification notification = new NotificationCompat.Builder(context).setSmallIcon(R.drawable.ic_launcher)
            .setContentTitle(missedMessage.substring(missedMessage.indexOf("=") + 1, missedMessage.length()))
            .setContentText("")
            .setContentIntent(pendingIntent)
            .setAutoCancel(true)
            .build();
    mNotificationManager.notify(R.string.notification_number, notification);
}

private void register() {
    new AsyncTask() {
        protected Object doInBackground(final Object... params) {

            try {
                String instanceId = InstanceID.getInstance(getApplicationContext()).getId();
                //token = gcm.register(getString(R.string.project_number));
                token = InstanceID.getInstance(getApplicationContext()).getToken(getString(R.string.project_number), INSTANCE_ID_SCOPE);
                Log.i("registrationId", token);
            } catch (IOException e) {
                Log.i("Registration Error", e.getMessage());
            }
            return true;
        }

        @Override
        protected void onPostExecute(Object o) {
            super.onPostExecute(o);
            new SendRegUserId().execute();
        }
    }.execute();
}

public IBinder onBind(Intent arg0) {
    return null;
}
}

Answer 1

使用Broadcast Receiver接收通知，然后将其发送到Service。这样，您就可以在不启动应用的情况下向用户发送notification。

======
修改1：

因此，您的广播接收器需要启动服务而不是调用其方法。因此，在检查意图为null之后，还有以下内容：

    ComponentName comp = new ComponentName(context.getPackageName(), YourIntentService.class.getName());
    startWakefulService(context, (intent.setComponent(comp));
    setResultCode(Activity.RESULT_OK);

此外，如果您仍希望在手机关机后收到通知，则Broadcast Receiver应该延长WakefulBroadcastReceiver。

此外，您的Service应该是IntentService。我认为Android Studio实际上附带了一些预先制作的GCM类或GCM应用程序，它实际上会处理你所拥有的这些小问题的90％。这是一个更好的起点。

查看GCM docs以获取更多帮助。

Answer 2

一些可能的解决方案 -

1）使用BroadcastReceiver

2）使用onPause（），onResume（）方法

 SharedPreferences prefs=PreferenceManager.getDefaultSharedPreferences(getApplicationContext());

 Intent messageReceivingIntent = new Intent(this,MessageReceivingService.class);

  onCreate(){

   //YOUR OWN CODE
   prefs.getBoolean("service_started",false);
 }

 onPause(){

 //YOUR OWN CODE
 prefs.edit().putBoolean("service_started",true).apply(); 
 startService(messageReceivingIntent);
}

onResume(){

 //YOUR OWN CODE
if(prefs.getBoolean("service_started",false)){
  stopService(new Intent(this, MessageReceivingService.class));
  prefs.edit().putBoolean("service_started",false).apply();
 }
}

3）或者根据我的最佳做法是实施Firebase Cloud Messaging以进行通知。

查看https://firebase.google.com/docs/cloud-messaging/

它大大减少了您的电池和服务器工作量。它是Google推出的一项全新服务。

或者我认为您的服务代码中可能存在错误

android运行服务自动启动应用程序

2 个答案: