精华内容
下载资源
问答
  • 安卓监听打电话

    2018-03-24 17:32:34
    安卓监听打电话(去电) 最近公司接到一个需求:需要安卓监听用户打出去的电话,并记录在自己的数据库中,也就是说不能查询通话记录。现在网上的东西千篇一律,所以写点自己的理解。 目录 安卓监听打电话...

    安卓监听打电话(去电)

    最近公司接到一个需求:需要安卓端监听用户打出去的电话,并记录在自己的数据库中,也就是说不能查询通话记录。现在网上的东西千篇一律,所以写点自己的理解。


    目录

    需要用到的工具:

    TelephonyManager
    PhoneStateListener
    BroadcastReceiver
    Intent.ACTION_NEW_OUTGOING_CALL
    android.permission.PROCESS_OUTGOING_CALLS
    android.permission.READ_PHONE_STATE

    实现方案

    首先注册广播接收者去电监听,用TelephonyManager监听电话状态

    greendao Bean字段

    @Entity
    public class VisitPhoneRecord {
        @Id(autoincrement = true)
        private Long id;
        @NotNull
        private long startTime;
        @NotNull
        private long endTime;
        @NotNull
        private String phoneNumber;
    }

    广播接收者代码

    logger工具com.orhanobut:logger
    包含数据库存入操作

    public class PhoneReceiver extends BroadcastReceiver {
        private boolean isListen = false;
        private String phoneNumber;
        private long startTime;
    
        @Override
        public void onReceive(Context context, Intent intent) {
            if (!isListen) {
                TelephonyManager tm = (TelephonyManager) context.getSystemService(Service.TELEPHONY_SERVICE);
                if (tm != null) {
                    tm.listen(listener, PhoneStateListener.LISTEN_CALL_STATE);
                    isListen = true;
                }
            }
            Logger.t("xxxx").d(intent.getAction());
            //去电
            if (Objects.equals(intent.getAction(), Intent.ACTION_NEW_OUTGOING_CALL)) {
                String phoneNumber = intent.getStringExtra(Intent.EXTRA_PHONE_NUMBER);
                if (!TextUtils.isEmpty(phoneNumber)) {//只有不是空号码的时候我才记在内存中
                    startTime = System.currentTimeMillis();
                    this.phoneNumber = phoneNumber;
                }
                Logger.t("xxxx").d("call OUT:" + phoneNumber);
            }
        }
    
        PhoneStateListener listener = new PhoneStateListener() {
            @Override
            public void onCallStateChanged(int state, String incomingNumber) {
                switch (state) {
                    case TelephonyManager.CALL_STATE_IDLE:
                        Logger.t("xxxx").d("挂断" + incomingNumber);
                        if (TextUtils.equals(phoneNumber, incomingNumber)) {//这边只要有初始时间,有结束时间,是同一个号码那么就在数据库里面加一条数据
                            VisitPhoneRecordDao recordDao = HomeApp.getInstance().getDaoSession().getVisitPhoneRecordDao();
                            long endTime = System.currentTimeMillis();
                            recordDao.insertOrReplace(new VisitPhoneRecord(null, startTime, endTime, incomingNumber));
                        }
                        break;
                    case TelephonyManager.CALL_STATE_OFFHOOK:
                        //如果是来电,这个必须点击接听按钮才会调用
                        //如果是拨打,那么一开始就会调用,并不是打通了之后才会调用
                        Logger.t("xxxx").d("摘机状态,接听或者拨打" + incomingNumber);
                        break;
                    case TelephonyManager.CALL_STATE_RINGING:
                        Logger.t("xxxx").d("响铃:来电号码:" + incomingNumber);
                        break;
                }
            }
        };
    }

    activity中的注册代码

        private PhoneReceiver receiver;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            ...
            IntentFilter filter = new IntentFilter();
            filter.addAction(Intent.ACTION_NEW_OUTGOING_CALL);
            receiver = new PhoneReceiver();
            registerReceiver(receiver, filter);
        }
    
        @Override
        protected void onDestroy() {
            super.onDestroy();
            ...
            unregisterReceiver(receiver);
        }

    权限

    Manifest中

    <uses-permission android:name="android.permission.PROCESS_OUTGOING_CALLS"/>
    <uses-permission android:name="android.permission.READ_PHONE_STATE" />

    权限我用的RxPermissions

    RxPermissions rxPermissions = new RxPermissions(this); 
    rxPermissions.request(
        Manifest.permission.PROCESS_OUTGOING_CALLS,
        Manifest.permission.READ_PHONE_STATE,) //权限名称,多个权限之间逗号分隔开
                    .subscribe(granted -> {
                        // 在android 6.0之前会默认返回true
                        if (granted) {
                            //权限通过后,检查APP是否需要更新,并且直接登陆
                            goLogin();
                        } else {
                            // 权限未通过
                            AlertDialog alertDialog = new AlertDialog.Builder(this)
                                    .setTitle("您没有授权该权限,请在设置中打开授权,重新进入APP登录")
                                    .setPositiveButton("确定", (dialog, which) -> {
                                        Uri packageURI = Uri.parse("package:" + BuildConfig.APPLICATION_ID);
                                        Intent intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS, packageURI);
                                        startActivity(intent);
                                        HomeApp.exitApp();
                                    })
                                    .setNegativeButton("取消", (dialog, which) -> MyApplication.exitApp()).create();
                            alertDialog.setCanceledOnTouchOutside(false);
                            alertDialog.setOnKeyListener((dialog, keyCode, event) -> keyCode == KeyEvent.KEYCODE_BACK);
                            alertDialog.show();
                        }
                    });

    坑点

    1.TelephonyManager

    首先来讲一下TelephonyManager,这个东西有点坑

    public void listen(PhoneStateListener listener, int events)

    实测,TelephonyManager如果是在activity中获取的,上面这个方法在你调用过后
    PhoneStateListener 的

    public void onCallStateChanged(int state, String incomingNumber)

    这个方法只会被调用一次,而如果TelephonyManager是通过BroadcastReceiver中onReceive的Context获取的那么就会多次调用。

    TelephonyManager的第二个坑爹的地方是没有办法注销listener。经过实验发现注册这个广播的activity挂了之后onCallStateChanged方法也只会被调用一次了,所以并不用担心注册了之后需要注销。所以尽量不要静态注册这个广播接收者。
    错误示范

    <receiver android:name=".PhoneReceiver">   
        <intent-filter>   
            <action android:name="android.intent.action.PHONE_STATE"/>   
            <action android:name="android.intent.action.NEW_OUTGOING_CALL" />   
        </intent-filter>   
    </receiver>   

    2.PhoneStateListener

    错误示范

    //注意,方法必须写在super方法后面,否则incomingNumber无法获取到值。
    super.onCallStateChanged(state, incomingNumber);

    首先这行代码并不需要调用,源码父类都是空实现,上面的注解更是无稽之谈

    3.BroadcastReceiver

    第一:这个玩意里面你才能够用TelephonyManager
    第二:这个尽量动态注册
    第三:

    <action android:name="android.intent.action.PHONE_STATE"/>

    这个可以不需要,你不需要用这个action让Receiver每次都收到电话状态的变化。因为PhoneStateListener已经跟你监听了,除非你想自己用Receiver写而不用PhoneStateListener监听。**
    第四:去电监听只会在你拨打电话号码得时候才会被回掉,如果你想监听来电请不要像我这样写你还是需要注册PHONE_STATE这个action来初始化PhoneStateListener

    总结

    网上抄手多,想要弄清楚要么自己试,要么看文档。以上算是我记录一些坑点,毕竟文档也写得很粗糙。

    展开全文
  • 主要介绍了安卓监听屏幕的横竖翻转实现方法,有需要的朋友可以参考一下
  • Android监听网络变化 二

    千次阅读 2019-01-17 16:48:55
    通用的监听网络变化见Android监听网络变化 这篇文件讲Android SDK版本的不同,监听网络变化方式也不同。 使用BroadcastReceiver 使用广播监听网络变化,这个在Android监听网络变化已经讲过了,详情见Android监听网络...

    通用的监听网络变化见Android监听网络变化
    这篇文件讲Android SDK版本的不同,监听网络变化方式也不同。

    使用BroadcastReceiver

    使用广播监听网络变化,这个在Android监听网络变化已经讲过了,详情见Android监听网络变化

    使用requestNetwork

    这个是android5.0 sdk 21新添加的API,使用方法如下

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
       ConnectivityManager manager = (ConnectivityManager) getSystemService(CONNECTIVITY_SERVICE);
       manager.requestNetwork(new NetworkRequest.Builder().build(),
               new ConnectivityManager.NetworkCallback() {
                   @Override
                   public void onAvailable(Network network) {
                       super.onAvailable(network);
                       Log.i("aaa", "监听,网络可用");
                   }
                   @Override
                   public void onLost(Network network) {
                       super.onLost(network);
                       Log.i("aaa", "监听,网络断开");
                   }
               });
    }
    

    使用registerDefaultNetworkCallback

    这个是android7.0 SDK 24添加的API,使用方法如下

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
    	   ConnectivityManager manager = (ConnectivityManager) getSystemService(CONNECTIVITY_SERVICE);
       manager.registerDefaultNetworkCallback(new ConnectivityManager.NetworkCallback() {
           @Override
           public void onLost(Network network) {
               super.onLost(network);
               Log.i("aaa", "注册,网络可用");
           }
           @Override
           public void onAvailable(Network network) {
               super.onAvailable(network);
               Log.i("aaa", "注册,网络可用");
    }
    

    取消监听

    不管使用requestNetwork方式,还是registerDefaultNetworkCallback方式,取消监听的方式是相同的,使用unregisterNetworkCallback方法,

    ConnectivityManager manager = (ConnectivityManager) getSystemService(CONNECTIVITY_SERVICE);
    manager.unregisterNetworkCallback(new ConnectivityManager.NetworkCallback());
    

    注意

    这些API需要申请网络权限,在注册文件添加权限

    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    <uses-permission android:name="android.permission.INTERNET"/>
    <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE"/>
    

    致谢

    感谢你的阅读,欢迎点赞和评论!

    展开全文
  • Android 监听框架开发教程 蓝牙状态监听例子 kotlin前言文件架构代码监听者注解状态值枚举类编写接口业务逻辑暴露接口 单例混淆封装完事 前言 有些时候,我们需要在某些Activity中监听某些状态。当然不可能在每个...

    前言

    有些时候,我们需要在某些Activity中监听某些状态。当然不可能在每个Activity中创建一个实例去查询和绑定吧。这时候,就需要一个统一管理状态的框架,下面就以蓝牙状态监听为例,描述如何开发一个监听框架。

    文件架构

    在这里插入图片描述

    代码

    监听者注解

    创建文件 RDBluetoothObserver ,注解类,用于描述监听者的方法

    /**
     * 蓝牙状态观察者注解
     *
     * @author D10NG
     * @date on 2019-11-12 09:25
     */
    @kotlin.annotation.Target(AnnotationTarget.FUNCTION)
    @kotlin.annotation.Retention(AnnotationRetention.RUNTIME)
    annotation class RDBluetoothObserver
    

    状态值枚举类

    创建文件 RDBluetoothStatus

    /**
     * 蓝牙开关状态
     *
     * @author D10NG
     * @date on 2019-11-12 09:27
     */
    enum class RDBluetoothStatus(val msg: String) {
    
        NONE(msg = "当前设备不支持蓝牙BLE"),
        STATE_TURNING_ON(msg = "正在打开蓝牙"),
        STATE_ON(msg = "蓝牙已打开"),
        STATE_TURNING_OFF(msg = "正在关闭蓝牙"),
        STATE_OFF(msg = "蓝牙已关闭"),
        CONNECTED(msg = "蓝牙已连接"),
        DISCONNECTED(msg = "蓝牙已断开连接")
    
    }
    

    编写接口

    创建文件 IBluetoothCallBack

    /**
     * 蓝牙状态接口
     *
     * @author D10NG
     * @date on 2019-11-12 09:30
     */
    interface IBluetoothCallBack {
    
        /**
         * 注册
         * @param obj
         */
        fun register(obj: Any)
    
        /**
         * 取消注册
         * @param obj
         */
        fun unRegister(obj: Any)
    
        /**
         * 取消注册
         */
        fun unRegisterAll()
    
        /**
         * 打开蓝牙
         */
        fun openBluetooth()
    
        /**
         * 关闭蓝牙
         */
        fun closeBluetooth()
    
        /**
         * 获取蓝牙状态
         * @return
         */
        fun getBluetoothStatus() : RDBluetoothStatus
    }
    
    

    业务逻辑

    创建文件 BluetoothCallBack

    /**
     * 蓝牙状态监听
     *
     * @author D10NG
     * @date on 2019-11-12 09:31
     */
    class BluetoothCallBack constructor(
        application: Application
    ) : IBluetoothCallBack {
    
        // 观察者,key=类、value=方法
        private val checkManMap = HashMap<Any, Method>()
    
        @Volatile
        private var bluetoothStatus: RDBluetoothStatus
    
        private val bluetoothReceiver = BluetoothReceiver()
    
        init {
            // 初始化广播
            val intentFilter = IntentFilter()
            // 监视蓝牙关闭和打开的状态
            intentFilter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED)
            intentFilter.addAction(BluetoothDevice.ACTION_ACL_DISCONNECTED)
            intentFilter.addAction(BluetoothDevice.ACTION_ACL_CONNECTED)
            // 开始监听
            application.registerReceiver(bluetoothReceiver, intentFilter)
    
            // 初始化蓝牙状态
            val bleManager = application.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
            val adapter = bleManager.adapter
            bluetoothStatus = when {
                adapter == null -> RDBluetoothStatus.NONE
                adapter.isEnabled -> RDBluetoothStatus.STATE_ON
                else -> RDBluetoothStatus.STATE_OFF
            }
        }
    
        override fun register(obj: Any) {
            val clz = obj.javaClass
            if (!checkManMap.containsKey(clz)) {
                val method = AnnotationUtils.findAnnotationMethod(
                    clz, RDBluetoothObserver::class.java,
                    RDBluetoothStatus::class.java) ?: return
                checkManMap[obj] = method
            }
        }
    
        override fun unRegister(obj: Any) {
            checkManMap.remove(obj)
        }
    
        override fun unRegisterAll() {
            checkManMap.clear()
        }
    
        override fun openBluetooth() {
            val ble = BluetoothAdapter.getDefaultAdapter()
            ble?.enable()
        }
    
        override fun closeBluetooth() {
            val ble = BluetoothAdapter.getDefaultAdapter()
            ble?.disable()
        }
    
        override fun getBluetoothStatus(): RDBluetoothStatus = bluetoothStatus
    
        // 执行
        private fun post(status: RDBluetoothStatus) {
            bluetoothStatus = status
            val set: Set<Any> = checkManMap.keys
            for (obj in set) {
                val method = checkManMap[obj] ?: continue
                method.invoke(obj, status)
            }
        }
    
        inner class BluetoothReceiver : BroadcastReceiver() {
    
            override fun onReceive(context: Context?, intent: Intent?) {
                val action = intent?.action ?: return
                when (action) {
                    BluetoothAdapter.ACTION_STATE_CHANGED -> {
                        when(intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, 0)) {
                            BluetoothAdapter.STATE_TURNING_ON -> post(RDBluetoothStatus.STATE_TURNING_ON)
                            BluetoothAdapter.STATE_ON -> post(RDBluetoothStatus.STATE_ON)
                            BluetoothAdapter.STATE_TURNING_OFF -> post(RDBluetoothStatus.STATE_TURNING_OFF)
                            BluetoothAdapter.STATE_OFF -> post(RDBluetoothStatus.STATE_OFF)
                        }
                    }
                    BluetoothDevice.ACTION_ACL_CONNECTED -> {
                        post(RDBluetoothStatus.CONNECTED)
                    }
                    BluetoothDevice.ACTION_ACL_DISCONNECTED -> {
                        post(RDBluetoothStatus.DISCONNECTED)
                    }
                }
            }
        }
    }
    
    

    暴露接口 单例

    创建文件 RDBluetoothManager

    /**
     * 蓝牙管理器
     *
     * @author D10NG
     * @date on 2019-11-12 09:24
     */
    class RDBluetoothManager constructor(
        application: Application
    ) : IBluetoothCallBack {
    
        private val bluetoothCallBack : IBluetoothCallBack
    
        companion object {
    
            @Volatile
            private var INSTANCE : RDBluetoothManager? = null
    
            @JvmStatic
            fun getInstance(application: Application) : RDBluetoothManager {
                val temp = INSTANCE
                if (null != temp) {
                    return temp
                }
                synchronized(this) {
                    val instance = RDBluetoothManager(application)
                    INSTANCE = instance
                    return instance
                }
            }
        }
    
        init {
            bluetoothCallBack = BluetoothCallBack(application)
        }
    
        override fun register(obj: Any) {
            bluetoothCallBack.register(obj)
        }
    
        override fun unRegister(obj: Any) {
            bluetoothCallBack.unRegister(obj)
        }
    
        override fun unRegisterAll() {
            bluetoothCallBack.unRegisterAll()
        }
    
        override fun openBluetooth() {
            bluetoothCallBack.openBluetooth()
        }
    
        override fun closeBluetooth() {
            bluetoothCallBack.closeBluetooth()
        }
    
        override fun getBluetoothStatus(): RDBluetoothStatus = bluetoothCallBack.getBluetoothStatus()
    
    }
    
    

    混淆封装

    如果你想打包成第三方库的话,看我的另一篇文章:
    Android 简单开发sdk教程一 接口写法和混淆规则

    Github

    DL10BluetoothListener

    完事

    展开全文
  • android监听手机app启动

    2016-12-02 18:30:47
    android监听app的启动,在API20以前用ActivityManager获取栈顶最近的应用,但API20以后捕捉不到手机上软件包名,这个更改可以获取最近打开app的包名,从而监听打开的APP。
  • Android 监听文件夹

    2018-09-17 14:55:00
    在一次Android和pc端的通讯...本篇简单Android监听文件夹的方式FileObserver。 FileObserver简介 Android.os包下的FileObserver类是一个用于监听文件访问、创建、修改、删除、移动等操作的监听器,基于Linux的INo...

    在一次Androidpc端的通讯过程中,我们放弃了adb forward来实现socket通讯。而是使用adb push文件,我监听文件夹... 都学习一下很有必要

    本篇简单Android监听文件夹的方式FileObserver

    FileObserver简介

    Android.os包下的FileObserver类是一个用于监听文件访问、创建、修改、删除、移动等操作的监听器,基于LinuxINotify

    FileObserver是个抽象类,必须继承它才能使用。每个FileObserver对象监听一个单独的文件或者文件夹,如果监视的是一个文件夹,那么文件夹下所有的文件和级联子目录的改变都会触发监听的事件。

    FileObserver使用

    
    package com.example.chenjy.chenjy;
    
    import android.os.FileObserver;
    
    import utils.LogUtil;
    
    /**
     * Created by chenjy on 2017/5/2.
     */
    
    public class FileListener extends FileObserver {
    
        private EventCallback callback;
    
        public FileListener(String path) {
            super(path);
        }
    
        public void setEventCallback(EventCallback callback){
            this.callback = callback;
        }
    
        @Override
        public void onEvent(int event, String path) {
            LogUtil.i("FileListener", "path="+path);
            switch (event){
                // 文件被访问
                case FileObserver.ACCESS:
                    LogUtil.i("FileListener", "ACCESS");
                    break;
                // 文件被修改
                case FileObserver.MODIFY:
                    LogUtil.i("FileListener", "MODIFY");
                    break;
                // 文件属性被修改
                case FileObserver.ATTRIB:
                    LogUtil.i("FileListener", "ATTRIB");
                    break;
                // 可写文件被close
                case FileObserver.CLOSE_WRITE:
                    LogUtil.i("FileListener", "CLOSE_WRITE");
                    if(callback != null){
                        callback.onEvent(path);
                    }
                    break;
                // 不可写文件被close
                case FileObserver.CLOSE_NOWRITE:
                    LogUtil.i("FileListener", "CLOSE_NOWRITE");
                    break;
                // 文件被打开
                case FileObserver.OPEN:
                    LogUtil.i("FileListener", "OPEN");
                    break;
                // 文件被移走
                case FileObserver.MOVED_FROM:
                    LogUtil.i("FileListener", "MOVED_FROM");
                    break;
                // 文件被移进来
                case FileObserver.MOVED_TO:
                    LogUtil.i("FileListener", "MOVED_TO");
                    break;
                // 文件被删除
                case FileObserver.DELETE:
                    LogUtil.i("FileListener", "DELETE");
                    break;
                // 创建新文件
                case FileObserver.CREATE:
                    LogUtil.i("FileListener", "CREATE");
                    break;
                // 自删除
                case FileObserver.DELETE_SELF:
                    LogUtil.i("FileListener", "DELETE_SELF");
                    break;
                // 自移动
                case FileObserver.MOVE_SELF:
                    LogUtil.i("FileListener", "MOVE_SELF");
                    break;
            }
        }
    
        public interface EventCallback{
            void onEvent(String path);
        }
    }
    
    

    FileObserver调用

    
    package com.example.chenjy.chenjy;
    
    import android.app.Activity;
    import android.os.Bundle;
    import android.os.Environment;
    
    public class MainActivity extends Activity {
    
        public static final String FILE_PATH = Environment.getExternalStorageDirectory().getAbsolutePath()+"/Pictures";
    
    
        private FileListener fileListener = new FileListener(FILE_PATH);
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            fileListener.startWatching();
    
        }
    
    }
    
    

    运行app

    outPut

    然后通过adb pushandroid 设备push图片。

    outPut

    outPut

    outPut

    转载于:https://www.cnblogs.com/chenjy1225/p/9662151.html

    展开全文
  • Android监听事件

    2016-06-11 17:50:32
    关于Android监听事件的一些认识。Android中的监听事件是通过接口回调来实现的。下面我来说说清Android中是如何设置监听器的。
  • AndroidAndroid 监听网络状态+源代码

    千次下载 热门讨论 2013-04-07 11:34:57
    AndroidAndroid 监听网络状态+源代码
  • android 监听网络状态的变化及实战

    万次阅读 多人点赞 2016-11-02 15:14:13
    怎样监听网络状态的变化,包括是否打开WiFi,否打开数据网络,当前连接的网络是否可用 网络没有打开情况下的处理,如弹出对话框,跳转到 打开 WiFi设置的界面等 非WiFi情况下是否 非WiFi情况下是否加载图片,是否...
  • 主要介绍了Android 监听锁屏、解锁、开屏 功能代码的相关资料,需要的朋友可以参考下
  • Android 监听百度地图缩放事件
  • 安卓监听软键盘搜索键 1、EditText中添加**android:imeOptions=”actionSearch” android:singleLine=”true”**两行,注意:不能使用AS推荐使用的maxLines=“1”,否则不会弹出搜索键 ...
  • android监听SD卡状态

    2017-06-16 17:23:49
    android监听SD卡状态注意事项
  • Android监听系统通知

    千次阅读 2019-05-12 15:11:51
    Android监听系统通知1. API简介2. 系统监听功能实现2.1 新建NotificationMonitor类继承自NotificationListenerService,这是监听系统消息的核心服务类2.2 NotificationMonitor服务类需要在AndroidManifest.xml中注册...
  • Android 监听EditText文本输入 EditText监听事和输入事件
  • 本篇文章主要介绍了Android监听软键盘弹出与隐藏的两种方法,非常具有实用价值,需要的朋友可以参考下
  • android监听全局监听

    千次阅读 2016-06-24 10:37:18
    在activity中 注册该监听,该监听是优先级最高的。返回true时其它监听则不会接受到。 private void takeOverEvents() {  getActivity().getWindow().setCallback(  new CallbackAgent(getActivity()) {  
  • android 监听手机开机

    2017-09-13 08:49:24
    android 监听手机开机。 需求描述:有些时候,我们需要我们的程序在开机后能自动运行,在系统即将关闭时,能写入一些记录到指定的文件里。 一、开机广播监听:  Android系统启动完成后会发出启动完成...
  • Android 监听开机广播

    千次阅读 2017-07-05 10:36:09
    Android 监听开机广播,实现程序自启 手机开机,会发送一条广播,可以注册一个广播接受者,当接受到这条广播的时候,即可执行需要执行的操作。 需要在AndroidManifest.xml中,注册广播,原样复制,修改成自己的...
  • Android监听锁屏亮屏

    2020-07-27 16:22:40
    Android监听锁屏亮屏 class ScreenBroadcastReceiver extends BroadcastReceiver { @Override public void onReceive(Context context, Intent intent) { String action = intent.getAction(); Log.d(TAG, ...
  • Android监听手机网络变化

    千次阅读 2015-12-22 14:05:49
    Android监听手机网络变化 手机网络状态发生变化会发送广播,利用广播接收者,监听手机网络变化 效果图注册广播接收者 <manifest xmlns:android="http://schemas.android.com/apk/res/android" package="……" > ...
  • Android 监听软键盘搜索键

    千次阅读 2016-03-29 22:21:37
    Android 监听软键盘搜索键,实现直接点击搜索键盘进行数据搜索
  • android监听Notification

    千次阅读 2015-08-04 17:17:12
    android手机用户应该都知道通知,随着智能穿戴设备的发展,特别是智能手表,用户的需求之一就是把QQ消息和微信消息等显示到手表上,那么怎么去获得这些消息呢?由于,qq消息和微信消息等会以Notification的形式显示...
  • 在开发Android应用的时候有时需要监听Settings下面的值,这个时候可以通过ContentObserver 来监听值的变化。1.首先自定义一个类继承ContentObserver。在onChange()方法里面再次去获取Settings的值。class ...
  • android监听软键盘enter按键,网上找了几个方案都不好使,自己打印日志,得出下面这个方式 password.setOnEditorActionListener(new TextView.OnEditorActionListener() { @Override public boolean ...
  • Android监听键盘弹出收起

    万次阅读 多人点赞 2016-07-27 10:22:40
    Android监听键盘弹出收起
  • Android 监听软键盘显示和隐藏

    千次阅读 2018-10-08 16:43:39
    Android 监听软键盘显示和隐藏 Android Span应用 1. 监听软键盘 由于官方没有提供相关的监听,只能通过界面布局来判断软键盘显示和隐藏。 (1) 通过OnLayoutChangeListener来监听 getWindow().getDecorView()....
  • Android监听进入和退出第三方应用

    千次阅读 2017-08-08 14:13:45
    Android监听进入和退出第三方应用
  • Android监听

    2015-10-17 10:58:18
    Android**监听器** 本文介绍了事件监听器的设计目的、运行流程和使用方法

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 263,787
精华内容 105,514
关键字:

安卓监听