java类android.content.IntentFilter的实例源码

@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;
    }}

}

private void registerReceiver() {
    if (mRegisteredTimeZoneReceiver) {
        return;
    }
    mRegisteredTimeZoneReceiver = true;
    IntentFilter filter = new IntentFilter(Intent.ACTION_TIMEZONE_CHANGED);
    MyWatchFace.this.registerReceiver(mTimeZoneReceiver, filter);
}

public void start(Context context, List<App> appsToMonitor) {
    this.context = context;
    this.appsToMonitor = appsToMonitor;
    this.lastSeenRunningApps = new ArrayList();
    IntentFilter filter = new IntentFilter();
    filter.addAction("android.intent.action.SCREEN_OFF");
    filter.addAction("android.intent.action.SCREEN_ON");
    filter.addAction(ACTION_MONITOR_APPS);
    this.receiver = new AppMonitorReceiver();
    context.registerReceiver(this.receiver, filter);
    if (((PowerManager) context.getSystemService("power")).isScreenOn()) {
        startMonitoring();
    }
}

/**
 * Starts bluetooth and listens to pairing requests and bluetooth state changes
 */
public static void startBluetoothServices() {
    mReceiver = new BluetoothReceiver();
    //Register the BroadcastReceiver for multiple bluetooth actions

    //when another bluetooth device is discovered in range
    IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);

    //when discovering action finishes (discovering means that bluetooth searches for nearby devices)
    filter.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
    //when bluetooth changes from on to off
    filter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);

    //when another device requests pairing with this device
    filter.addAction(BluetoothDevice.ACTION_PAIRING_REQUEST);

    mainActivity.mainRegisterReceiver(mReceiver, filter);

    if(!started) {
        //tries to start bluetooth if it is not on
       mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
        if(mBluetoothAdapter!=null){
            if (!mBluetoothAdapter.isEnabled()) {
                Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
                mainActivity.startActivityForResult(enableBtIntent, MainActivity.BLUETOOTH_ON);
            } else {
                started = true;
            }
        }

    }
}

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_usb);

    mStatusView = (TextView) findViewById(R.id.text_status);
    mResultView = (TextView) findViewById(R.id.text_result);

    mUsbManager = getSystemService(UsbManager.class);

    // Detach events are sent as a system-wide broadcast
    IntentFilter filter = new IntentFilter(UsbManager.ACTION_USB_DEVICE_DETACHED);
    registerReceiver(mUsbReceiver, filter);

    handleIntent(getIntent());
}

void requestPushToken(Activity activity){
    if (activity!=null) {
        Intent service = new Intent(activity, RegistrationIntentService.class);
        service.putExtra(RegistrationIntentService.TOKEN, "token");
        activity.startService(service);

        IntentFilter intentFilter = new IntentFilter(RegistrationIntentService.ACTION_TOKEN);
        intentFilter.addCategory(Intent.CATEGORY_DEFAULT);
        activity.registerReceiver(tokenBroadcastReceiver, intentFilter);

        //send back first
        sendBroadCast();
    }
    else{

    }
}

public static void protectIntentFilter(IntentFilter filter) {
    if (filter != null) {
        List<String> actions = mirror.android.content.IntentFilter.mActions.get(filter);
        ListIterator<String> iterator = actions.listIterator();
        while (iterator.hasNext()) {
            String action = iterator.next();
            if (SpecialComponentList.isActionInBlackList(action)) {
                iterator.remove();
                continue;
            }
            if (SYSTEM_BROADCAST_ACTION.contains(action)) {
                continue;
            }
            String newAction = SpecialComponentList.protectAction(action);
            if (newAction != null) {
                iterator.set(newAction);
            }
        }
    }
}

/**
 * Used to check whether there is a specialized handler for a given intent.
 * @param intent The intent to check with.
 * @return Whether there is a specialized handler for the given intent.
 */
private static boolean hasSpecializedHandlerIntents(Context context, Intent intent) {
    try {
        PackageManager pm = context.getPackageManager();
        List<ResolveInfo> handlers = pm.queryIntentActivities(
                intent,
                PackageManager.GET_RESOLVED_FILTER);
        if (handlers == null || handlers.size() == 0) {
            return false;
        }
        for (ResolveInfo resolveInfo : handlers) {
            IntentFilter filter = resolveInfo.filter;
            if (filter == null) continue;
            if (filter.countDataAuthorities() == 0 || filter.countDataPaths() == 0) continue;
            if (resolveInfo.activityInfo == null) continue;
            return true;
        }
    } catch (RuntimeException e) {
        Log.e(TAG, "Runtime exception while getting specialized handlers");
    }
    return false;
}

private static boolean hasSpecializedHandlerIntents(Context context, Intent intent) {
    try {
        PackageManager pm = context.getPackageManager();
        List<ResolveInfo> handlers = pm.queryIntentActivities(
                intent,
                PackageManager.GET_RESOLVED_FILTER);
        if (handlers == null || handlers.size() == 0) {
            return false;
        }
        for (ResolveInfo resolveInfo : handlers) {
            IntentFilter filter = resolveInfo.filter;
            if (filter == null) continue;
            if (filter.countDataAuthorities() == 0 || filter.countDataPaths() == 0) continue;
            if (resolveInfo.activityInfo == null) continue;
            return true;
        }
    } catch (RuntimeException e) {
        Log.e("Error", "Runtime exception while getting specialized handlers");
    }
    return false;
}

private void registerReceiver() {
    if (mRegisteredTimeZoneReceiver) {
        return;
    }
    mRegisteredTimeZoneReceiver = true;
    IntentFilter filter = new IntentFilter(Intent.ACTION_TIMEZONE_CHANGED);
    DigitalWatchFaceService.this.registerReceiver(mTimeZoneReceiver, filter);
}

/**
 * {@inheritDoc}
 */
@Override
public void onStart() {
    super.onStart();
    final IntentFilter filter = new IntentFilter();
    // Play and pause changes
    filter.addAction(MusicPlaybackService.PLAYSTATE_CHANGED);
    // Shuffle and repeat changes
    filter.addAction(MusicPlaybackService.SHUFFLEMODE_CHANGED);
    filter.addAction(MusicPlaybackService.REPEATMODE_CHANGED);
    // Track changes
    filter.addAction(MusicPlaybackService.META_CHANGED);
    // Player prepared
    filter.addAction(MusicPlaybackService.PREPARED);
    // Update a list, probably the playlist fragment's
    filter.addAction(MusicPlaybackService.REFRESH);
    getActivity().registerReceiver(mPlaybackStatus, filter);
    // Refresh the current time
    final long next = refreshCurrentTime();
    queueNextRefresh(next);

    MusicUtils.notifyForegroundStateChanged(getActivity(), isPlaying());
}

public void onCreate(Bundle bundle){
    super.onCreate(bundle);
    mUpdateReceiver = new BroadcastReceiver(){
        @Override
        public void onReceive(Context context, Intent intent) {
            if(intent!=null&& ArchosMediaIntent.ACTION_VIDEO_SCANNER_SCAN_FINISHED.equals(intent.getAction())) {
                getLoaderManager().restartLoader(LOADER_ID_LAST_ADDED, null, MainFragment.this);
                Log.d(TAG, "manual reload");
            }
        }
    };

    mUpdateFilter = new IntentFilter();
    for(String scheme : UriUtils.sIndexableSchemes){
        mUpdateFilter.addDataScheme(scheme);
    }
    mUpdateFilter.addAction(ArchosMediaIntent.ACTION_VIDEO_SCANNER_SCAN_FINISHED);
}

/** 注册广播接受来自keyboard的车牌号 */
    public void registerReceiver() {
//        输入车牌完成后的intent过滤器
        IntentFilter finishFilter = new IntentFilter(INPUT_LICENSE_COMPLETE);
        receiver = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                String license = intent.getStringExtra(INPUT_LICENSE_KEY);
                if (license != null && license.length() > 0) {
                    if (keyboardUtil != null) {
                        keyboardUtil.hideKeyboard();
                    }
                    KeyBoardPopWindow.this.dismiss();
                    mListener.setLicense(license);
                }
            }
        };
        mContext.registerReceiver(receiver, finishFilter);
    }

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    findViewById(R.id.btn_default).setOnClickListener(this);
    findViewById(R.id.btn_custom).setOnClickListener(this);
    findViewById(R.id.btn_demo).setOnClickListener(this);

    mLlRemoteViewsContainer = (LinearLayout) findViewById(R.id.ll_remote_views);

    mNotificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);

    IntentFilter intentFilter = new IntentFilter(DemoActivity.ACTION_REMOTE_VIEWS);
    registerReceiver(mBroadcastReceiver, intentFilter);
}

@TargetApi(Build.VERSION_CODES.KITKAT)
@RpcMinSdk(Build.VERSION_CODES.KITKAT)
@Rpc(
    description =
            "Connects to a paired or discovered device with A2DP profile."
                    + "If a device has been discovered but not paired, this will pair it."
)
public void btA2dpConnect(String deviceAddress) throws Throwable {
    BluetoothDevice device = BluetoothAdapterSnippet.getKnownDeviceByAddress(deviceAddress);
    IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_PAIRING_REQUEST);
    mContext.registerReceiver(new PairingBroadcastReceiver(mContext), filter);
    Utils.invokeByReflection(sA2dpProfile, "connect", device);
    if (!Utils.waitUntil(
            () -> sA2dpProfile.getConnectionState(device) == BluetoothA2dp.STATE_CONNECTED,
            120)) {
        throw new BluetoothA2dpSnippetException(
                "Failed to connect to device "
                        + device.getName()
                        + "|"
                        + device.getAddress()
                        + " with A2DP profile within 2min.");
    }
}

public PixelWallpaperEngine() {

    prefs = PreferenceManager.getDefaultSharedPreferences(PixelWallpaperService.this);

    Resources res = getResources();

          borderDefault = res.getBoolean(R.bool.pref_border_default);
          blackWhiteDefault = res.getBoolean(R.bool.pref_black_white_default);
    touchmodeDefault = res.getString(R.string.pref_touch_default);
    pixelsizeDefault = res.getString(R.string.pref_pixel_default);
    framerateDefault = res.getString(R.string.pref_frame_default);

          boolean blackWhiteMode = prefs.getBoolean(PreferencesActivity.PREF_BLACK_WHITE, blackWhiteDefault);
    border = prefs.getBoolean(PreferencesActivity.PREF_BORDER, borderDefault);
    touchmode = Integer.valueOf(prefs.getString(PreferencesActivity.PREF_TOUCH, touchmodeDefault));
    pixelsize = Integer.valueOf(prefs.getString(PreferencesActivity.PREF_PIXEL, pixelsizeDefault));
    framerate = Integer.valueOf(prefs.getString(PreferencesActivity.PREF_FRAME, framerateDefault));
    prefs.registerOnSharedPreferenceChangeListener(this);

    IntentFilter filter = new IntentFilter(Intent.ACTION_SHUTDOWN);
    shutdownReceiver = new ShutdownReceiver(this);
    registerReceiver(shutdownReceiver, filter);

    WindowManager wm = (WindowManager) getSystemService(Context.WINDOW_SERVICE);
    Display d = wm.getDefaultDisplay();
    DisplayMetrics dm = new DisplayMetrics();
    d.getMetrics(dm);

    height = dm.heightPixels;
    width = dm.widthPixels;

    pa = new PixelArray(touchmode, blackWhiteMode);

}

public synchronized void onResume() {
  if (registered) {
    Log.w(TAG, "PowerStatusReceiver was already registered?");
  } else {
    activity.registerReceiver(powerStatusReceiver, new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
    registered = true;
  }
  onActivity();
}

/**
 * 添加
 */
public void register(String action, BroadcastReceiver receiver) {
    try {
        IntentFilter filter = new IntentFilter();
        filter.addAction(action);
        mContext.registerReceiver(receiver, filter);
        mReceiverMap.put(action, receiver);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

@Override
public void onEnabled(Context context) {
    IntentFilter filter = new IntentFilter();
    filter.addAction(AppIntent.ACTION_UPDATE_LIST_WIDGET);
    filter.addAction(AppIntent.ACTION_UPDATE_LAYOUT_LIST_WIDGET);

    LocalBroadcastManager.getInstance(context).registerReceiver(this, filter);

    scheduleUpdate(context);
}

@Override
protected void onStart() {
    super.onStart();
    IntentFilter intentFilter = new IntentFilter();
    intentFilter.addAction(Constant.VIDEO_PAUSE_OPERATE);
    intentFilter.addAction(Constant.VIDEO_STOP_OPERATE);
    registerReceiver(mReceiver, intentFilter);
}

public View onCreateView(LayoutInflater inflater, ViewGroup container,
                         Bundle savedInstanceState) {
    rootView = inflater.inflate(R.layout.friends_fragment, container, false);
    SharedPreferences prefs=getActivity().getSharedPreferences("user", Context.MODE_PRIVATE);
    SharedPreferences.Editor editor=prefs.edit();
    username=prefs.getString("username"," ");

    localBroadcastManger=LocalBroadcastManager.getInstance(getActivity());
    intentFilter=new IntentFilter();
    intentFilter.addAction("com.shmily.tjz.swap.LOCAL_SPECIAL");
    localReceiver=new LocalReceiver();
    localBroadcastManger.registerReceiver(localReceiver,intentFilter);
    friends_recy= (RecyclerView) rootView.findViewById(R.id.friends_recy);
    swipRefresh= (SwipeRefreshLayout) rootView.findViewById(R.id.swipRefresh);
    friends_fragment_load_layout= (LoadingLayout) rootView.findViewById(R.id.friends_fragment_load_layout);

    friends_fragment_load_layout.setStatus(LoadingLayout.Loading);
    set_username= (TextView) rootView.findViewById(R.id.set_username);
    friends_headview= (CircleImageView) rootView.findViewById(R.id.friends_headview);


    set_username.setText(username);
    headimage_url="http://www.shmilyz.com/headimage/"+username+".jpg";

    findnumber();
    swipRefresh.setColorSchemeColors(getResources().getColor(R.color.colorPrimary));
    swipRefresh.setOnRefreshListener(new SwipeRefreshLayout.OnRefreshListener() {
        @Override
        public void onRefresh() {

            findnumber();
            adapter.notifyDataSetChanged();
            swipRefresh.setRefreshing(false);

        }
    });
    return rootView;
}

private void register() {
    IntentFilter usbFilter = new IntentFilter();
    usbFilter.addAction(UsbManager.ACTION_USB_DEVICE_ATTACHED);
    usbFilter.addAction(UsbManager.ACTION_USB_DEVICE_DETACHED);
    usbFilter.addAction(ACTION_USB_PERMISSION);
    Activity activity = ctx.get();
    if (activity != null) {
        activity.registerReceiver(mUsbPermissionActionReceiver, usbFilter);
    }
}

public void registerReceiver(Context context, TimeListener timeListener) {
    try {
        IntentFilter filter = new IntentFilter();
        filter.addAction(Intent.ACTION_TIME_CHANGED);
        filter.addAction(Intent.ACTION_TIME_TICK);
        filter.addAction(Intent.ACTION_TIMEZONE_CHANGED);
        filter.setPriority(Integer.MAX_VALUE);
        context.registerReceiver(this, filter);
        this.timeListener = timeListener;
    } catch (Exception e) {
        e.printStackTrace();
    }
}

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

    broadcastManager.registerReceiver(broadcastReceiver, new IntentFilter(BlockchainService.ACTION_PEER_STATE));

    forceLoad();
}

/**
 * Register a pending intent with the AlarmManager to be broadcasted every
 * half hour and register the alarm broadcast receiver to receive this
 * intent. The receiver will check all known questions if a ping is
 * Necessary when invoked by the alarm intent.
 *
 * @param context
 */
public static void onCreate(Context context) {
    sContext = context;
    context.registerReceiver(ALARM_BROADCAST_RECEIVER, new IntentFilter(PING_ALARM_ACTION));
    sAlarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
    sPendingIntent = PendingIntent.getBroadcast(context, 0, new Intent(PING_ALARM_ACTION), 0);
    sAlarmManager.setInexactRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP,
            SystemClock.elapsedRealtime() + PING_INTERVAL,
            PING_INTERVAL, sPendingIntent);
}

private void registerListener() {
    IntentFilter filter = new IntentFilter();
    filter.addAction(Intent.ACTION_SCREEN_ON);
    filter.addAction(Intent.ACTION_SCREEN_OFF);
    filter.addAction("android.media.VOLUME_CHANGED_ACTION");
    registerReceiver(mReceiver, filter);
}

@Override
protected void onResume() {
    super.onResume();
    registerReceiver(
            receiver,
            new IntentFilter(SocketListeningService.MESSAGE_RECEIVED));
}

@Override
public void onCreate() {
    Log.d(TAG, "onCreate");
    googleApiClient = new GoogleApiClient.Builder(this)
        .addConnectionCallbacks(this)
        .addOnConnectionFailedListener(this)
        .addApi(LocationServices.API)
        .build();
    googleApiClient.connect();

    createLocationRequest("highest");

    LocationSettingsRequest.Builder builder = new LocationSettingsRequest.Builder();
    builder.addLocationRequest(locationRequest);
    builder.setAlwaysShow(true); // "This app wants to change your device settings for GPS location"
    locationSettingsRequest = builder.build();

    HandlerThread handlerThread = new HandlerThread(TAG);
    handlerThread.start();
    handler = new Handler(handlerThread.getLooper());
    notificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);

    currentNotificationTitle = getResources().getString(R.string.app_name);
    currentNotificationText = getResources().getString(R.string.notification_desc);

    // Handling interaction with WiFi
    wifiConnected = Utils.isWifiConnected(getApplicationContext());

    // Listening to Network changes (WiFi mostly)
    IntentFilter intentFilter = new IntentFilter();
    intentFilter.addAction("android.net.wifi.WIFI_STATUS_CHANGED");
    intentFilter.addAction("android.net.wifi.STATUS_CHANGE");

    registerReceiver(AtNetworkReceiver, intentFilter);
}

private void monitorRepoUpdates() {
    if (isInEditMode()) {
        return;
    }

    LocalBroadcastManager.getInstance(getContext()).registerReceiver(onRepoFeedback,
            new IntentFilter(UpdateService.LOCAL_ACTION_STATUS));
    setBannerIsVisible(UpdateService.isUpdating());
}

/**
 * 广播拦截
 *
 * @return IntentFilter
 */
public static IntentFilter makeFilters() {
    IntentFilter intentFilter = new IntentFilter();
    intentFilter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);//开关监听
    intentFilter.addAction(BluetoothDevice.ACTION_FOUND);//查询
    intentFilter.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);//查询结束
    intentFilter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED);//绑定状况
    return intentFilter;
}