下面列出了android.content.Context#registerReceiver ( ) 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
public MediaServiceHandler(Context context, ServiceUtils serviceUtils) {
this.mContext = context;
this.mServiceUtils = serviceUtils;
IntentFilter intentFilter = new IntentFilter();
intentFilter.addAction(Constants.IA_HIDE_MEDIA);
context.registerReceiver(mBroadcastReceiver, intentFilter);
// Run on main thread
final Handler handler = new Handler(mContext.getMainLooper());
handler.post(new Runnable() {
@Override
public void run() {
prepareMediaSession();
handler.removeCallbacksAndMessages(null);
}
});
}
@Override
public boolean onCreate() {
Context context = getContext();
updateSettings();
usbManager = (UsbManager) context.getSystemService(Context.USB_SERVICE);
IntentFilter filter = new IntentFilter();
filter.addAction(ACTION_USB_PERMISSION);
filter.addAction(UsbManager.ACTION_USB_DEVICE_ATTACHED);
filter.addAction(UsbManager.ACTION_USB_DEVICE_DETACHED);
context.registerReceiver(mUsbReceiver, filter);
updateRoots();
return true;
}
/** Test only interface, not for public use */
public EntropyMixer(
Context context,
String entropyFile,
String randomDevice,
String hwRandomDevice) {
if (randomDevice == null) { throw new NullPointerException("randomDevice"); }
if (hwRandomDevice == null) { throw new NullPointerException("hwRandomDevice"); }
if (entropyFile == null) { throw new NullPointerException("entropyFile"); }
this.randomDevice = randomDevice;
this.hwRandomDevice = hwRandomDevice;
this.entropyFile = entropyFile;
loadInitialEntropy();
addDeviceSpecificEntropy();
addHwRandomEntropy();
writeEntropy();
scheduleEntropyWriter();
IntentFilter broadcastFilter = new IntentFilter(Intent.ACTION_SHUTDOWN);
broadcastFilter.addAction(Intent.ACTION_POWER_CONNECTED);
broadcastFilter.addAction(Intent.ACTION_REBOOT);
context.registerReceiver(
mBroadcastReceiver,
broadcastFilter,
null, // do not require broadcaster to hold any permissions
mHandler // process received broadcasts on the I/O thread instead of the main thread
);
}
public static synchronized ConnectivityActionReceiver getInstance(Context context) {
if (staticInstance == null) {
staticInstance = new ConnectivityActionReceiver();
IntentFilter filter = new IntentFilter();
filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
context.registerReceiver(staticInstance, filter);
}
return staticInstance;
}
public static synchronized ConnectivityActionReceiver getInstance(Context context) {
if (staticInstance == null) {
staticInstance = new ConnectivityActionReceiver();
IntentFilter filter = new IntentFilter();
filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
context.registerReceiver(staticInstance, filter);
}
return staticInstance;
}
/**
* https://developer.android.com/training/monitoring-device-state/battery-monitoring.html
*/
public static int getBatteryState(Context context) {
IntentFilter ifilter = new IntentFilter(Intent.ACTION_BATTERY_CHANGED);
Intent batteryStatus = context.registerReceiver(null, ifilter);
if (batteryStatus == null) {
return BatteryManager.BATTERY_STATUS_UNKNOWN;
}
return batteryStatus.getIntExtra(BatteryManager.EXTRA_STATUS, -1);
}
@TargetApi(Build.VERSION_CODES.LOLLIPOP_MR1)
static void sendChooserIntent(boolean saveLastUsed, Activity activity,
Intent sharingIntent,
@Nullable TargetChosenCallback callback) {
synchronized (LOCK) {
if (sTargetChosenReceiveAction == null) {
sTargetChosenReceiveAction = activity.getPackageName() + "/"
+ TargetChosenReceiver.class.getName() + "_ACTION";
}
Context context = activity.getApplicationContext();
if (sLastRegisteredReceiver != null) {
context.unregisterReceiver(sLastRegisteredReceiver);
// Must cancel the callback (to satisfy guarantee that exactly one method of
// TargetChosenCallback is called).
// TODO(mgiuca): This should be called immediately upon cancelling the chooser,
// not just when the next share takes place (https://crbug.com/636274).
sLastRegisteredReceiver.cancel();
}
sLastRegisteredReceiver = new TargetChosenReceiver(saveLastUsed, callback);
context.registerReceiver(
sLastRegisteredReceiver, new IntentFilter(sTargetChosenReceiveAction));
}
Intent intent = new Intent(sTargetChosenReceiveAction);
intent.setPackage(activity.getPackageName());
intent.putExtra(EXTRA_RECEIVER_TOKEN, sLastRegisteredReceiver.hashCode());
final PendingIntent pendingIntent = PendingIntent.getBroadcast(activity, 0, intent,
PendingIntent.FLAG_CANCEL_CURRENT | PendingIntent.FLAG_ONE_SHOT);
Intent chooserIntent = Intent.createChooser(sharingIntent,
activity.getString(R.string.share_link_chooser_title),
pendingIntent.getIntentSender());
if (sFakeIntentReceiverForTesting != null) {
sFakeIntentReceiverForTesting.setIntentToSendBack(intent);
}
fireIntent(activity, chooserIntent);
}
/**
* This method starts listening for network connectivity state changes.
*
* @param context app context
*/
public synchronized void startListening(Context context, ConnectivityListener connectivityListener) {
if (mListener == null) {
mContext = context;
mMainHandler = new Handler(context.getMainLooper());
mListener = connectivityListener;
IntentFilter filter = new IntentFilter();
filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
context.registerReceiver(mReceiver, filter);
}
}
/**
* 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 an Android 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() + AlarmManager.INTERVAL_HALF_HOUR,
AlarmManager.INTERVAL_HALF_HOUR, sPendingIntent);
}
/**
* Obtains the current battery voltage value.
*
* @param context Application context
* @return Returns the battery voltage
*/
public static double getBatteryVoltage(final Context context) {
Intent receiver = context.registerReceiver(
null,
new IntentFilter(Intent.ACTION_BATTERY_CHANGED)
);
if (receiver == null) return 0;
double voltage = receiver.getIntExtra(BatteryManager.EXTRA_VOLTAGE, 0);
return (voltage == 0) ? voltage : voltage / 1000;
}
/**
* Be sure to remove receiver at appropriate time (i.e. in Activity.onPause()).
*/
@RequiresPermission(Manifest.permission.ACCESS_NETWORK_STATE)
public static void register(@NonNull Context context, @NonNull ConnectivityListener listener) {
if (receiversMap.containsKey(listener)) {
throw new RuntimeException("Connectivity listener " + listener
+ " is already registered");
}
final ConnectivityReceiver receiver = new ConnectivityReceiver(listener);
receiversMap.put(listener, receiver);
context.registerReceiver(receiver,
new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION));
receiver.notify(isConnected(context));
}
/**
* 获取APKDownloader实例,同时注册DOWNLOAD_COMPLETE
*
* @return APKDownloader对象
*/
public static APKDownloader getInstance(Context context) {
Assert.notNull(context);
if (mInstance == null) {
mInstance = new APKDownloader();
mDownloadManager = (DownloadManager) context.getSystemService(Context.DOWNLOAD_SERVICE);
IntentFilter intentfilter = new IntentFilter();
intentfilter.addAction("android.intent.action.DOWNLOAD_COMPLETE");
context.registerReceiver(receiver, intentfilter);
}
return mInstance;
}
FloatLifecycle(Context applicationContext, boolean showFlag, Class[] activities, LifecycleListener lifecycleListener) {
this.showFlag = showFlag;
this.activities = activities;
num++;
mLifecycleListener = lifecycleListener;
mHandler = new Handler();
((Application) applicationContext).registerActivityLifecycleCallbacks(this);
applicationContext.registerReceiver(this, new IntentFilter(Intent.ACTION_CLOSE_SYSTEM_DIALOGS));
}
public static void getNearWifiList(final Context context, final WifiReceiver.IReceiveNewNetWorks listener)
{
WifiManager manager= (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
final WifiReceiver receiver=new WifiReceiver(manager);
WifiReceiver.IReceiveNewNetWorks wListener=new WifiReceiver.IReceiveNewNetWorks() {
WifiReceiver _receiver=receiver;
@Override
public void onReceive(ArrayList<ScanResult> list) {
listener.onReceive(list);
if(_receiver!=null)
{
try
{
context.unregisterReceiver(_receiver);
_receiver=null;
}catch (Exception e)
{
e.printStackTrace();
}
}
}
};
receiver.setReceiveListener(wListener);
manager.disconnect();
if(!manager.isWifiEnabled())
manager.setWifiEnabled(true);
IntentFilter filter=new IntentFilter(WifiManager.WIFI_STATE_CHANGED_ACTION);
filter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY);
context.registerReceiver(receiver,filter);
}
/**
* Register a BroadcastReceiver in the given context.
*/
public void registerReceiver(Context context) {
context.registerReceiver(getBroadcastReceiver(), getIntentFilter());
}
public RxDownloader(@NonNull Context context) {
this.context = context.getApplicationContext();
DownloadStatusReceiver downloadStatusReceiver = new DownloadStatusReceiver();
IntentFilter intentFilter = new IntentFilter(DownloadManager.ACTION_DOWNLOAD_COMPLETE);
context.registerReceiver(downloadStatusReceiver, intentFilter);
}
public void init(Context context) {
LogUtil.d(TAG, "init()");
IntentFilter intentFilter = new IntentFilter(UPDATE_WEATHER_ACTION);
context.registerReceiver(mReceiver, intentFilter);
context.sendBroadcast(new Intent(REQUEST_UPDATE_WEATHER_ACTION));
}
/**
* Register a BroadcastReceiver in the given context.
*/
public void registerReceiver(Context context) {
context.registerReceiver(getBroadcastReceiver(), getIntentFilter());
}
public void register(Context context){
IntentFilter intentFilter = new IntentFilter();
intentFilter.addAction(BlueService.ACTION_MESSAGE_REVEIVER);
context.registerReceiver(this,intentFilter);
}
public static Intent getBatteryStatus(Context context) {
Context appContext = context.getApplicationContext();
return appContext.registerReceiver(null,
new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
}