使用选项卡时，通知不会在Android中显示

我正在编写一个应用程序，其中我使用两个选项卡，一个用于获取facebook好友列表，另一个选项卡用于获取电话簿好友列表

在“电话簿好友”选项卡中，我还可以获得好友的生日信息，并显示该信息的提醒，如果我单独尝试，而不与其他选项卡组合（即：使用Facebook选项卡），我也可以获得提醒

这意味着一旦我把它合并到标签中，我就不会收到任何生日通知

我正在使用以下类获取电话簿好友生日的通知：

   public class BirthdayReminder extends ListActivity {
// TODO: call/write message on birthday
// TODO: hideNotificationPref

private final DateFormatSymbols dateSymbols = new DateFormatSymbols();

private Database db;

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    getListView().setFastScrollEnabled(true);

    this.db = new Database(getContentResolver());

    // debug code
    // Debug.logDatabase(this);

    // start BirthdayBroadcastReceiver if it is activated
    Preferences prefs = Preferences.getInstance(getApplicationContext());
    if (prefs.getActivateService()) {
        BirthdayBroadcastReceiver.restart(getApplicationContext());
    }
}

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

    updateView();
}

private void updateView() {
    // create new list adapter
    MultiListAdapter listAdapter = new MultiListAdapter();
    List<ListAdapter> adapterList = listAdapter.getListAdapters();

    // load birthday and contact information
    List<Contact> contacts = this.db.getAllContacts();
    List<BirthContact> birthContacts = BirthContactHelper.createBirthContactList(contacts);

    // group all contacts by known and unknown birthday
    SortedSet<BirthContact> knownBirthdays = new TreeSet<BirthContact>(new BirthContactBirthdayComparator());
    SortedSet<BirthContact> unknownBirthdays = new TreeSet<BirthContact>(new BirthContactNameComparator());

    for (BirthContact birthContact : birthContacts) {
        DateOfBirth dateOfBirth = birthContact.getDateOfBirth();

        if (dateOfBirth != null) {
            knownBirthdays.add(birthContact);
        } else {
            unknownBirthdays.add(birthContact);
        }
    }

    Integer currentMonth = null;
    BirthContactAdapter currentBirthContactAdapter = null;
    String[] monthStrs = this.dateSymbols.getMonths();
    for (BirthContact birthContact : knownBirthdays) {
        int month = birthContact.getDateOfBirth().getDate().get(Calendar.MONTH);

        if (currentMonth == null || currentMonth != month) {
            currentMonth = month;

            currentBirthContactAdapter = new BirthContactAdapter(this);
            adapterList.add(new CategoryAdapter(this, monthStrs[currentMonth]));
            adapterList.add(currentBirthContactAdapter);
        }

        currentBirthContactAdapter.add(birthContact);
    }

    adapterList.add(new CategoryAdapter(this, getResources().getString(R.string.unknownBirthdays)));
    adapterList.add(new BirthContactAdapter(this, unknownBirthdays));

    setListAdapter(listAdapter);
}

@Override
protected void onListItemClick(ListView l, View v, int position, long id) {
    BirthContact birthContact = (BirthContact) l.getAdapter().getItem(position);

    Intent editorIntent = new Intent(this, BirthdayEditor.class);
    editorIntent.putExtra(BirthdayEditor.CONTACT_ID, birthContact.getContact().getId());
    startActivity(editorIntent);
}

@Override
public boolean onCreateOptionsMenu(Menu menu) {
    MenuInflater inflater = getMenuInflater();
    inflater.inflate(R.layout.menu, menu);
    return true;
}

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    // Handle item selection
    switch (item.getItemId()) {
    case R.id.preferences:
        startActivity(new Intent(this, PreferenceWindow.class));
        return true;
    case R.id.quit:
        finish();
        return true;
    default:
        return super.onOptionsItemSelected(item);
    }
}
   }

通知:

   public class BirthdayBroadcastReceiver extends BroadcastReceiver {

private static final String TIMED = "timed";

@Override
public void onReceive(Context context, Intent intent) {
    if (intent.getBooleanExtra(TIMED, false)) {
        notifyBirthdays(context);
    }

    start(context);
}

private static PendingIntent createPendingIntent(Context context) {
    Intent intent = new Intent(context, BirthdayBroadcastReceiver.class);
    intent.putExtra(TIMED, true);
    return PendingIntent.getBroadcast(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);
}

public static void start(Context context) {
    AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
    PendingIntent pendingIntent = createPendingIntent(context);

    Preferences prefs = Preferences.getInstance(context);
    Time nextUpdateTime = prefs.getUpdateTime();

    Calendar wakeUpCal = Calendar.getInstance();
    wakeUpCal.set(Calendar.HOUR_OF_DAY, nextUpdateTime.getHours());
    wakeUpCal.set(Calendar.MINUTE, nextUpdateTime.getMinutes());
    wakeUpCal.set(Calendar.SECOND, wakeUpCal.getActualMinimum(Calendar.SECOND));
    wakeUpCal.set(Calendar.MILLISECOND, wakeUpCal.getActualMinimum(Calendar.MILLISECOND));

    if (wakeUpCal.before(Calendar.getInstance())) {
        wakeUpCal.add(Calendar.DAY_OF_MONTH, 1);
    }

    alarmManager.set(AlarmManager.RTC_WAKEUP, wakeUpCal.getTimeInMillis(), pendingIntent);
}

public static void stop(Context context) {
    AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
    PendingIntent pendingIntent = createPendingIntent(context);
    alarmManager.cancel(pendingIntent);
    pendingIntent.cancel();
}

public static void restart(Context context) {
    stop(context);
    start(context);
}

private void notifyBirthdays(Context context) {
    Calendar today = CalendarUtils.todaysCalendar();
    Database db = new Database(context.getContentResolver());

    Preferences prefs = Preferences.getInstance(context);
    NotificationManager notificationManager = (NotificationManager) context
            .getSystemService(Context.NOTIFICATION_SERVICE);
    Resources res = context.getResources();

    List<Contact> contacts = db.getAllContacts();

    // calculate next birthdays
    SortedMap<Integer, List<String>> nextBirthdays = new TreeMap<Integer, List<String>>();
    for (Contact contact : contacts) {
        Integer timeSpanToNextBirthday = null;
        for (RawContact rawContact : contact.getRawContacts()) {
            for (DateOfBirth dateOfBirth : rawContact.getDatesOfBirth()) {
                int timeSpan = CalendarUtils.timeSpanToNextBirthday(today, dateOfBirth.getDate());

                if (timeSpanToNextBirthday == null || timeSpanToNextBirthday > timeSpan) {
                    timeSpanToNextBirthday = timeSpan;
                }
            }
        }

        if (timeSpanToNextBirthday != null && timeSpanToNextBirthday <= prefs.getDaysBeforeReminder()) {
            List<String> infoNames = nextBirthdays.get(timeSpanToNextBirthday);
            if (infoNames == null) {
                infoNames = new ArrayList<String>();
                nextBirthdays.put(timeSpanToNextBirthday, infoNames);
            }
            infoNames.add(contact.getName());
        }
    }

    // collect all sentences for the notification
    List<String> notificationTexts = new ArrayList<String>();
    int countBirthdays = 0;
    for (Integer days : nextBirthdays.keySet()) {
        List<String> birthdayList = nextBirthdays.get(days);
        String names = StringUtils.join(birthdayList, ", ").toString();
        notificationTexts.add(getBirthdayText(res, days, names));
        countBirthdays += birthdayList.size();
    }

    // cancel all notifications (clear old once)
    notificationManager.cancelAll();

    // create new notification
    if (notificationTexts.size() > 0) {
        String titleText = String.format(res.getQuantityString(R.plurals.notificationTitle, countBirthdays),
                countBirthdays);
        Intent intent = new Intent(context, BirthdayReminder.class);
        Notification notification = new Notification(R.drawable.balloons2, titleText, System.currentTimeMillis());
        if (countBirthdays > 1) {
            notification.number = countBirthdays;
        }
        PendingIntent pi = PendingIntent.getActivity(context, 0, intent, Intent.FLAG_ACTIVITY_NEW_TASK);
        notification.setLatestEventInfo(context, titleText, StringUtils.join(notificationTexts, ", "), pi);
        notificationManager.notify(0, notification);
    }
}

private String getBirthdayText(Resources res, int days, String names) {
    String text;
    switch (days) {
    case 0:
        text = String.format(res.getString(R.string.notificationText_today), names);
        break;
    case 1:
        text = String.format(res.getString(R.string.notificationText_tomorrow), names);
        break;
    default:
        text = String.format(res.getString(R.string.notificationText_other), days, names);
    }
    return text;
}
  }

public类BirthdayBroadcastReceiver扩展了BroadcastReceiver{
私有静态最终字符串TIMED=“TIMED”；
@凌驾
公共void onReceive（上下文、意图）{
if（intent.getBooleanExtra（TIMED，false））{
生日（上下文）；
}
开始（上下文）；
}
私有静态PendingEvent CreatePendingEvent（上下文）{
意向意向=新意向（上下文，BirthdayBroadcastReceiver.class）；
intent.putExtra（定时，真）；
返回PendingEvent.getBroadcast（上下文，0，意图，PendingEvent.FLAG_UPDATE_CURRENT）；
}
公共静态void开始（上下文）{
AlarmManager AlarmManager=（AlarmManager）context.getSystemService（context.ALARM\u服务）；
PendingEvent PendingEvent=CreatePendingEvent（上下文）；
Preferences prefs=Preferences.getInstance（上下文）；
Time nextUpdateTime=prefs.getUpdateTime（）；
Calendar wakeUpCal=Calendar.getInstance（）；
wakeUpCal.set（Calendar.HOUR\u OF_DAY，nextUpdateTime.getHours（））；
wakeUpCal.set（Calendar.MINUTE，nextUpdateTime.getMinutes（））；
wakeUpCal.set（Calendar.SECOND，wakeUpCal.getActualMinimum（Calendar.SECOND））；
wakeUpCal.set（Calendar.毫秒，wakeUpCal.getActualMinimum（Calendar.毫秒））；
if（wakeUpCal.before（Calendar.getInstance（）））{
wakeUpCal.add（日历日/月，1）；
}
alarmManager.set（alarmManager.RTC_WAKEUP，wakeUpCal.getTimeInMillis（），PendingContent）；
}
公共静态无效停止（上下文）{
AlarmManager AlarmManager=（AlarmManager）context.getSystemService（context.ALARM\u服务）；
PendingEvent PendingEvent=CreatePendingEvent（上下文）；
alarmManager.cancel（挂起事件）；
挂起。取消（）；
}
公共静态无效重新启动（上下文）{
停止（上下文）；
开始（上下文）；
}
私人生日（上下文）{
Calendar today=CalendarUtils.todaysCalendar（）；
Database db=新数据库（context.getContentResolver（））；
Preferences prefs=Preferences.getInstance（上下文）；
NotificationManager NotificationManager=（NotificationManager）上下文
.getSystemService（上下文通知服务）；
Resources res=context.getResources（）；
List contacts=db.getAllContacts（）；
//计算下一个生日
SortedMap nextbirthdys=新树映射（）；
用于（联系人：联系人）{
整数TimesPantonExtBirthy=null；
for（rawscontact-rawscontact:contact.getrawscontacts（））{
for（DateOfBirth DateOfBirth:rawContact.getDatesOfBirth（））{
int timeSpan=CalendarUtils.timespantonExtBirth（今天，dateOfBirth.getDate（））；
如果（TimesPantonExtDarthy==null | | TimesPantonExtDarthy>timeSpan）{
timeSpanToNextBirthday=timeSpan；
}
}
}
如果（TimesPantonExtBirthy！=null&&TimesPantonExtBirthy 0）{
String titleText=String.format（res.getQuantityString（R.plurals.notificationTitle，countBirthdays），
（包括生日）；
意向意向=新意向（上下文，birthdayrementer.class）；
通知通知=新通知（R.drawable.ballodes2，titleText，System.currentTimeMillis（））；
如果（countBirthdays>1）{
notification.number=count个生日；
}
PendingEvent pi=PendingEvent.getActivity（上下文，0，意图，意图。标记活动和新任务）；
notification.setLatestEventInfo（context，titleText，StringUtils.join（notificationtext，“，”），pi）；
notificationManager.notify（0，通知）；
}
}
私有字符串getBirthdayText（资源资源、整数天、字符串名称）{
字符串文本；
转换（天）{
案例0：
text=String.format（res.getString（R.String.notificationText_today），名称）；
打破
案例1：
text=String.format（res.getString（R.String.notificationText_），名称）；
打破
违约：
text=String.format（res.getString（R.String.notificationText_other）、天、名称）；
}
返回文本；
}
}

您是否在通知服务类中使用了正确的软件包名称，就像几个月前我做了相同类型的项目一样，我在同一个动作中挣扎，当我犯了错误时，我觉得很愚蠢：

这是正确的方法：

    <receiver android:name="packagename.BirthdayBroadcastReceiver" >
        <intent-filter>
            <action android:name="android.intent.action.BOOT_COMPLETED" />
        </intent-filter>
    </receiver>

    <receiver android:name="packagename.BirthdayBroadcastReceiver" >
        <intent-filter>
            <action android:name="android.intent.action.BOOT_COMPLETED" />
        </intent-filter>
    </receiver>