import android.support.v4.content.LocalBroadcastManager; //导入依赖的package包/类
@Override
public void onNotificationPosted(StatusBarNotification sbn) {
    String pack = sbn.getPackageName();
    String ticker = sbn.getNotification().tickerText.toString();
    Bundle extras = sbn.getNotification().extras;
    String title = extras.getString("android.title");
    String text = extras.getCharSequence("android.text").toString();

    Log.i("Package",pack);
    Log.i("Ticker",ticker);
    Log.i("Title",title);
    Log.i("Text",text);

    Intent msgrcv = new Intent("Msg");
    msgrcv.putExtra("package", pack);
    msgrcv.putExtra("ticker", ticker);
    msgrcv.putExtra("title", title);
    msgrcv.putExtra("text", text);

    LocalBroadcastManager.getInstance(context).sendBroadcast(msgrcv);


}
 

import android.support.v4.content.LocalBroadcastManager; //导入依赖的package包/类
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
                         Bundle savedInstanceState) {
    // Inflate the layout for this fragment
    View view = inflater.inflate(R.layout.fragment_station_lobby, container, false);

    IntentFilter filter = new IntentFilter();
    filter.addAction(StationActivity.ACTION_MAIN_SERVICE_BOUND);
    LocalBroadcastManager bm = LocalBroadcastManager.getInstance(getContext());
    bm.registerReceiver(mBroadcastReceiver, filter);

    lobbiesLayout = (LinearLayout) view.findViewById(R.id.lobbies_layout);

    update();

    return view;
}
 

import android.support.v4.content.LocalBroadcastManager; //导入依赖的package包/类
@Test
public void checksOnEventReceivedPushNotCalledWhenTelemetryDisabled() throws Exception {
  Context mockedContext = mock(Context.class, RETURNS_DEEP_STUBS);
  MapboxTelemetry.applicationContext = mockedContext;
  String aValidAccessToken = "validAccessToken";
  String aValidUserAgent = "MapboxTelemetryAndroid/";
  EventsQueue mockedEventsQueue = mock(EventsQueue.class);
  TelemetryClient mockedTelemetryClient = mock(TelemetryClient.class);
  Callback mockedHttpCallback = mock(Callback.class);
  SchedulerFlusher mockedSchedulerFlusher = mock(SchedulerFlusher.class);
  Clock mockedClock = mock(Clock.class);
  LocalBroadcastManager mockedLocalBroadcastManager = mock(LocalBroadcastManager.class);
  boolean indifferentServiceBound = true;
  MapboxTelemetry theMapboxTelemetry = new MapboxTelemetry(mockedContext, aValidAccessToken, aValidUserAgent,
    mockedEventsQueue, mockedTelemetryClient, mockedHttpCallback, mockedSchedulerFlusher, mockedClock,
    mockedLocalBroadcastManager, indifferentServiceBound);
  Event mockedEvent = mock(Event.class);

  theMapboxTelemetry.onEventReceived(mockedEvent);

  verify(mockedEventsQueue, never()).push(eq(mockedEvent));
}
 

import android.support.v4.content.LocalBroadcastManager; //导入依赖的package包/类
/**
 * @param action
 */
private final void registerReceiverAction(final String action) {
    IntentFilter filter = new IntentFilter(action);
    LocalBroadcastManager.getInstance(mContext).registerReceiver(new BroadcastReceiver() {

        @Override
        public void onReceive(Context context, Intent intent) {
            if (action.equals(intent.getAction())) {
                PluginInfo info = intent.getParcelableExtra("obj");
                if (info != null) {
                    switch (action) {
                        case ACTION_NEW_PLUGIN:
                            // 非常驻进程上下文
                            newPluginFound(info, intent.getBooleanExtra(RePluginConstants.KEY_PERSIST_NEED_RESTART, false));
                            break;
                        case ACTION_UNINSTALL_PLUGIN:
                            pluginUninstalled(info);
                            break;
                    }
                }
            }
        }
    }, filter);
}
 

import android.support.v4.content.LocalBroadcastManager; //导入依赖的package包/类
@Override
    public void onDestroy() {
        if (server != null) {
            try {
                LocalBroadcastManager.getInstance(this).unregisterReceiver(messageReceiver);
//                server.stop();
                server.shutdownNow();
                server = null;
                Intent statusIntent = new Intent(DeskDroidService.SERVER_STATUS_CHANGE);
                statusIntent.putExtra("running", false);
                LocalBroadcastManager.getInstance(this).sendBroadcast(statusIntent);
            } catch (Exception e) {
            }
        }
        super.onDestroy();
    }
 

import android.support.v4.content.LocalBroadcastManager; //导入依赖的package包/类
public AndroidJSTPConnection(String host, int port, boolean usesSSL, Context context) {
    mListeners = new CopyOnWriteArrayList<>();
    mTaggedCacheCalls = new ConcurrentHashMap<>();
    mConnectionState = STATE_NOT_CONNECTED;

    mNeedsRestoration = true;
    mContext = context;

    TCPTransport transport = new TCPTransport(host, port, usesSSL);
    mConnection = new Connection(transport, this);
    mConnection.addSocketListener(this);

    mBroadcastManager = LocalBroadcastManager.getInstance(mContext);

    initNetworkReceiver();
}
 

import android.support.v4.content.LocalBroadcastManager; //导入依赖的package包/类
@Override
public void onMessageReceived(MessageEvent messageEvent) {
    if (messageEvent.getPath().equals("/heartRate")) {
        final String message = new String(messageEvent.getData());
        Log.v("pactchat", "Message path received on watch is: " + messageEvent.getPath());
        Log.v("packtchat", "Message received on watch is: " + message);

        // Broadcast message to wearable activity for display
        Intent messageIntent = new Intent();
        messageIntent.setAction(Intent.ACTION_SEND);
        messageIntent.putExtra("heart", message);
        LocalBroadcastManager.getInstance(this).sendBroadcast(messageIntent);
    }
    else {
        super.onMessageReceived(messageEvent);
    }
}
 

import android.support.v4.content.LocalBroadcastManager; //导入依赖的package包/类
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    s = new Setting();
    Language = s.getLang();
    SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(getBaseContext());
    Language = preferences.getString("l",Language);
    setLanguage(Language);
    setContentView(R.layout.activity_main);
    BottomNavigationView navigation =  findViewById(R.id.navigation);
    navigation.setOnNavigationItemSelectedListener(mOnNavigationItemSelectedListener);
    fm=getSupportFragmentManager();
    fm.beginTransaction().add(R.id.content,new BlankFragment()).commit();
    Intent i = new Intent(this,SocketService.class);
    bindService(i,myConnection,Context.BIND_AUTO_CREATE);
    setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
    Log.e("Brodcast","Broadcast intent onCreate invoked");
    if(savedInstanceState == null){
    if(!registred){
        LocalBroadcastManager.getInstance(this).registerReceiver(mMessageReceiver,
                new IntentFilter("my-event"));
        Log.e("Registre","Broadcast intent  register");
        registred = true;
    }}

}
 

import android.support.v4.content.LocalBroadcastManager; //导入依赖的package包/类
/**
 * Cleanup the object
 * Should be called when the object is not used anymore
 */
public void cleanup() {
    stopDiscovering();
    //close discovery service
    Log.d(TAG, "closeServices ...");

    if (mArdiscoveryService != null) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                mArdiscoveryService.stop();

                mCtx.unbindService(mArdiscoveryServiceConnection);
                mArdiscoveryService = null;
            }
        }).start();
    }

    // unregister receivers
    LocalBroadcastManager localBroadcastMgr = LocalBroadcastManager.getInstance(mCtx);
    localBroadcastMgr.unregisterReceiver(mArdiscoveryServicesDevicesListUpdatedReceiver);
}
 

import android.support.v4.content.LocalBroadcastManager; //导入依赖的package包/类
@Override
public void onNotifactionShowedResult(Context context, XGPushShowedResult xgPushShowedResult) {
    LogUtils.d(TAG, xgPushShowedResult.toString());
    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss", Locale.CHINA);

    Notice notice = new Notice();
    notice.setTitle(xgPushShowedResult.getTitle());
    notice.setContent(xgPushShowedResult.getContent());
    notice.setTime(simpleDateFormat.format(new Date()));
    notice.setUserId(getLoginUser());
    NoticeDao noticeDao = getDaoSession().getNoticeDao();
    noticeDao.insert(notice);

    //发送广播通知更新
    Intent intent = new Intent(Constants.mainBroadcast);
    Bundle bundle = new Bundle();
    bundle.putInt("type", Constants.BROADCAST_TYPE_NOTICE);
    intent.putExtras(bundle);
    LocalBroadcastManager.getInstance(context).sendBroadcast(intent);
}
 

import android.support.v4.content.LocalBroadcastManager; //导入依赖的package包/类
@Test
public void checksUserAgentEvents() throws Exception {
  Context mockedContext = mock(Context.class, RETURNS_DEEP_STUBS);
  MapboxTelemetry.applicationContext = mockedContext;
  String aValidAccessToken = "validAccessToken";
  String theEventsAndroidAgent = "MapboxEventsAndroid/";
  EventsQueue mockedEventsQueue = mock(EventsQueue.class);
  TelemetryClient mockedTelemetryClient = mock(TelemetryClient.class);
  Callback mockedHttpCallback = mock(Callback.class);
  SchedulerFlusher mockedSchedulerFlusher = mock(SchedulerFlusher.class);
  Clock mockedClock = mock(Clock.class);
  LocalBroadcastManager mockedLocalBroadcastManager = mock(LocalBroadcastManager.class);
  boolean indifferentServiceBound = true;
  MapboxTelemetry theMapboxTelemetry = new MapboxTelemetry(mockedContext, aValidAccessToken, theEventsAndroidAgent,
    mockedEventsQueue, mockedTelemetryClient, mockedHttpCallback, mockedSchedulerFlusher, mockedClock,
    mockedLocalBroadcastManager, indifferentServiceBound);
  theMapboxTelemetry.enable();

  boolean validRequiredParameters = theMapboxTelemetry.checkRequiredParameters(aValidAccessToken,
    theEventsAndroidAgent);

  assertTrue(validRequiredParameters);
}
 

import android.support.v4.content.LocalBroadcastManager; //导入依赖的package包/类
@Override
public void run() {
    try {
        sleep(500);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    LocalBroadcastManager _manager = LocalBroadcastManager.getInstance(Global.get_applicationContext());
    SDFile _file;
    for (int _temp_i = 0; _temp_i < _files.size(); _temp_i++) {
        _file = _files.valueAt(_temp_i);
        _file.updateRubbish();
        Intent _update = new Intent(ACTION_UPDATE);
        _update.putExtra("index", _files.keyAt(_temp_i));
        _manager.sendBroadcast(_update);
    }
    Intent _finish = new Intent(ACTION_FINISH);
    _manager.sendBroadcast(_finish);
}
 

import android.support.v4.content.LocalBroadcastManager; //导入依赖的package包/类
@Test
public void checksInvalidUserAgent() throws Exception {
  Context mockedContext = mock(Context.class, RETURNS_DEEP_STUBS);
  MapboxTelemetry.applicationContext = mockedContext;
  String aValidAccessToken = "validAccessToken";
  String aInvalidUserAgent = "invalidUserAgent";
  EventsQueue mockedEventsQueue = mock(EventsQueue.class);
  TelemetryClient mockedTelemetryClient = mock(TelemetryClient.class);
  Callback mockedHttpCallback = mock(Callback.class);
  SchedulerFlusher mockedSchedulerFlusher = mock(SchedulerFlusher.class);
  Clock mockedClock = mock(Clock.class);
  LocalBroadcastManager mockedLocalBroadcastManager = mock(LocalBroadcastManager.class);
  boolean indifferentServiceBound = true;
  MapboxTelemetry theMapboxTelemetry = new MapboxTelemetry(mockedContext, aValidAccessToken, aInvalidUserAgent,
    mockedEventsQueue, mockedTelemetryClient, mockedHttpCallback, mockedSchedulerFlusher, mockedClock,
    mockedLocalBroadcastManager, indifferentServiceBound);
  theMapboxTelemetry.enable();

  boolean validRequiredParameters = theMapboxTelemetry.checkRequiredParameters(aValidAccessToken, aInvalidUserAgent);

  assertFalse(validRequiredParameters);
}
 

import android.support.v4.content.LocalBroadcastManager; //导入依赖的package包/类
static AccessTokenManager getInstance() {
    if (instance == null) {
        synchronized (AccessTokenManager.class) {
            if (instance == null) {
                Context applicationContext = FacebookSdk.getApplicationContext();
                LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance(
                        applicationContext);
                AccessTokenCache accessTokenCache = new AccessTokenCache();

                instance = new AccessTokenManager(localBroadcastManager, accessTokenCache);
            }
        }
    }

    return instance;
}
 

import android.support.v4.content.LocalBroadcastManager; //导入依赖的package包/类
@Override
protected void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);
	setContentView(R.layout.activity_list_with_header);

	// Get the list component from the layout of the activity
	final WearableListView listView = (WearableListView) findViewById(R.id.devices_list);
	listView.setAdapter(mDeviceAdapter = new DevicesAdapter(listView));
	listView.setClickListener(mOnRowClickListener);
	listView.addOnScrollListener(mOnScrollListener);

	// The header will be moved as the list is scrolled
	mHeader = findViewById(R.id.header);

	// Register a broadcast receiver that will listen for events from the service.
	LocalBroadcastManager.getInstance(this).registerReceiver(mServiceBroadcastReceiver, BleProfileService.makeIntentFilter());
}
 

import android.support.v4.content.LocalBroadcastManager; //导入依赖的package包/类
@Override
public void onCreate() {
    super.onCreate();
    Utils.debugLog(TAG, "creating Service");
    localBroadcastManager = LocalBroadcastManager.getInstance(this);
    appUpdateStatusManager = AppUpdateStatusManager.getInstance(this);

    BroadcastReceiver br = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            String packageName = intent.getData().getSchemeSpecificPart();
            for (AppUpdateStatusManager.AppUpdateStatus status : appUpdateStatusManager.getByPackageName(packageName)) {
                appUpdateStatusManager.updateApk(status.getUniqueKey(), AppUpdateStatusManager.Status.Installed, null);
            }
        }
    };
    IntentFilter intentFilter = new IntentFilter();
    intentFilter.addAction(Intent.ACTION_PACKAGE_ADDED);
    intentFilter.addDataScheme("package");
    registerReceiver(br, intentFilter);
}
 

import android.support.v4.content.LocalBroadcastManager; //导入依赖的package包/类
@Override
public void onDestroy() {
    super.onDestroy();

    if (mNotificationManager != null) {
        stopForeground(true);
    } else {
        stopSelf();
    }

    try {
        unregisterReceiver(mBroadcastReceiver);
        LocalBroadcastManager.getInstance(this).unregisterReceiver(mBroadcastReceiver);
    } catch (Throwable t) {
        t.printStackTrace();
    }

    mHandlerThread.quit();
}
 

import android.support.v4.content.LocalBroadcastManager; //导入依赖的package包/类
@Override
public void onCreate() {
    super.onCreate();
    LocalBroadcastManager.getInstance(getApplicationContext()).registerReceiver(phoneReceiver,new IntentFilter("receive_incoming_call"));
    LocalBroadcastManager.getInstance(getApplicationContext()).registerReceiver(phoneReceiver,new IntentFilter("rejected_incoming_call"));
    LocalBroadcastManager.getInstance(getApplicationContext()).registerReceiver(phoneReceiver,new IntentFilter("EXTRA_STATE_OFFHOOK"));
    //media player intents
    IntentFilter mediaPlayerFilter = new IntentFilter();
    mediaPlayerFilter.addAction(AppConstants.MediaPlayer.PLAY);
    mediaPlayerFilter.addAction(AppConstants.MediaPlayer.PAUSE);
    mediaPlayerFilter.addAction(AppConstants.MediaPlayer.BACK);
    mediaPlayerFilter.addAction(AppConstants.MediaPlayer.FORWARD);
    mediaPlayerFilter.addAction(AppConstants.MediaPlayer.STOP);
    mediaPlayerFilter.addAction(AppConstants.MediaPlayer.REPEAT_ON);
    mediaPlayerFilter.addAction(AppConstants.MediaPlayer.REPEAT_OFF);
    mediaPlayerFilter.addAction(Intent.ACTION_NEW_OUTGOING_CALL);
    registerReceiver(MediaPlayerBroadcast, mediaPlayerFilter);

    //screen on / of guard key unlock flag
    IntentFilter screenIntentFilter = new IntentFilter(Intent.ACTION_SCREEN_ON);
    screenIntentFilter.addAction(Intent.ACTION_SCREEN_ON);
    screenIntentFilter.addAction(Intent.ACTION_SCREEN_OFF);
    screenIntentFilter.addAction(Intent.ACTION_USER_PRESENT);
    registerReceiver(MediaPlayerNotificationShow, screenIntentFilter);


}
 

import android.support.v4.content.LocalBroadcastManager; //导入依赖的package包/类
private void callPvDataService() {
    BroadcastReceiver broadcastReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            LocalBroadcastManager.getInstance(context).unregisterReceiver(this);
            if (intent.getBooleanExtra("success", true)) {
                updateScreen();
            } else {
                Toast.makeText(context, intent.getStringExtra("message"),
                        Toast.LENGTH_LONG).show();
            }
        }
    };
    IntentFilter intentFilter = new IntentFilter(PvDataService.class.getName());
    LocalBroadcastManager.getInstance(getContext())
            .registerReceiver(broadcastReceiver, intentFilter);

    PvDataService.callDay(getContext(), picked.year, picked.month);
}
 

import android.support.v4.content.LocalBroadcastManager; //导入依赖的package包/类
private void sendProgressBroadcast(final int progress) {

        final long now = SystemClock.elapsedRealtime();
        final float speed = now - mLastProgressTime != 0 ? (float) (mBytesSent - mLastBytesSent) / (float) (now - mLastProgressTime) : 0.0f;
        final float avgSpeed = now - mStartTime != 0 ? (float) mBytesSent / (float) (now - mStartTime) : 0.0f;
        mLastProgressTime = now;
        mLastBytesSent = mBytesSent;

        final Intent broadcast = new Intent(BROADCAST_PROGRESS);
        broadcast.putExtra(EXTRA_DATA, progress);
        broadcast.putExtra(EXTRA_DEVICE_ADDRESS, mDeviceAddress);
        broadcast.putExtra(EXTRA_PART_CURRENT, mPartCurrent);
        broadcast.putExtra(EXTRA_PARTS_TOTAL, mPartsTotal);
        broadcast.putExtra(EXTRA_SPEED_B_PER_MS, speed);
        broadcast.putExtra(EXTRA_AVG_SPEED_B_PER_MS, avgSpeed);
        LocalBroadcastManager.getInstance(this).sendBroadcast(broadcast);
    }