Android 手机遥控器控制机顶盒（电视）

最新推荐文章于 2023-05-26 16:56:30 发布
最新推荐文章于 2023-05-26 16:56:30 发布
阅读量1.1w 收藏 24
点赞数 8
分类专栏： Android 机顶盒开发 文章标签： android socket 机顶盒 手机 电视
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Json_Jerry/article/details/77675990
版权

公司需求： 参考悟空遥控器做下手机控制机顶盒的功能，手机端apk界面参考遥控器，机顶盒apk在设置里面加个开关，打开的时候运行个后台server，手机端发送数据机顶盒的server接收到后处理相关动作。

需求出来了怎么实现呢？首先应用程序的通信无非就是Socket与Http,其中Socket又可以用TCP和UDP，HTTP的话就衍生出很多方式，基础的HTTP GET和POST请求，然后就是WebService的SOAP。

在这些方式中，Socket当然是最基础的。因此先从Socket开始。
首先是服务器端：打开服务器，等待客户端链接并接收消息即KeyCode，响应相应事件；
然后是客户端：模拟遥控器的UI界面，搭好界面，为每个控件添加点击事件并赋值相应KeyCode，连接服务器，将KeyCode信息传递给服务器端。
完成之后需要在资源配置文件中添加网络权限：

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

所有完成之后，测试时发现响应按键时只能在当前应用内使用，当离开此应用界面时，会报无权限异常，这时需要在Manifest.xml中添加
最高权限：

android:sharedUserId="android.uid.system"

这时需要在SDK下使用mk文件编译：
Android.mk

ifneq ($(BOARD_USE_DEFAULT_APPINSTALL),false)
LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)

LOCAL_MODULE_TAGS := optional

LOCAL_SRC_FILES := $(call all-subdir-java-files)

LOCAL_PACKAGE_NAME := RemoteTV
LOCAL_CERTIFICATE := platform

include $(BUILD_PACKAGE)
endif

整个思路就是这样，下面上代码：

ClientActivity,这里用到了StrictMode（严苛模式），不懂的可以百度了解了解，在这里我只做了数字键和上下左右键的模拟，有需要的可以自己添加:

public class ClientActivity extends Activity implements OnClickListener {
    private EditText mServerIp;
    private EditText mServerPort;
    private EventSender mEventSender;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()
                .detectDiskReads()
                .detectDiskWrites()
                .detectNetwork() 
                .penaltyLog() 
                .build());
        StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder()
                .detectLeakedSqlLiteObjects() 
                .penaltyLog() 
                .penaltyDeath()
                .build());
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_client);
        mServerIp = (EditText) findViewById(R.id.cli_adr_edi);
        mServerPort = (EditText) findViewById(R.id.cli_port_edi);
        findViewById(R.id.cli_connect_btn).setOnClickListener(this);
findViewById(R.id.num_1).setOnClickListener(this);
findViewById(R.id.num_2).setOnClickListener(this);
findViewById(R.id.num_3).setOnClickListener(this);
findViewById(R.id.num_4).setOnClickListener(this);
findViewById(R.id.num_5).setOnClickListener(this);
findViewById(R.id.num_6).setOnClickListener(this);
findViewById(R.id.num_7).setOnClickListener(this);
findViewById(R.id.num_8).setOnClickListener(this);
findViewById(R.id.num_9).setOnClickListener(this);
findViewById(R.id.btn_up).setOnClickListener(this);
findViewById(R.id.btn_left).setOnClickListener(this);
findViewById(R.id.btn_right).setOnClickListener(this);
findViewById(R.id.btn_down).setOnClickListener(this);
}
    @Override
    public void onClick(View v) {
        int code = -1;
        switch (v.getId()) {
            case R.id.cli_connect_btn:
                if(mEventSender != null) mEventSender.close();
                mEventSender = new EventSender(mServerIp.getText().toString(), Integer.valueOf(mServerPort.getText().toString()));
                mEventSender.connect();
                return;
            case R.id.num_1:
             code = KeyEvent.KEYCODE_1;
                break;
            case R.id.num_2:
                code = KeyEvent.KEYCODE_2;
                break;
            case R.id.num_3:
                code = KeyEvent.KEYCODE_3;
                break;
            case R.id.num_4:
                code = KeyEvent.KEYCODE_4;
                break;
            case R.id.num_5:
                code = KeyEvent.KEYCODE_5;
                break;
            case R.id.num_6:
                 code = KeyEvent.KEYCODE_6;
                break;
            case R.id.num_7:
                code = KeyEvent.KEYCODE_7;
                break;
            case R.id.num_8:
                code = KeyEvent.KEYCODE_8;
                break;
            case R.id.num_9:
                code = KeyEvent.KEYCODE_9;
                break;
            case R.id.btn_up:
                code=KeyEvent.KEYCODE_DPAD_UP;
                break;
              case R.id.btn_left:
                code=KeyEvent.KEYCODE_DPAD_LEFT;
                break;
            case R.id.btn_down:
                code=KeyEvent.KEYCODE_DPAD_DOWN;
                break;
            case R.id.btn_right:
                code=KeyEvent.KEYCODE_DPAD_RIGHT;
                break;
        }  
         if(mEventSender == null) return;
        mEventSender.println(createKeyEvent(new KeyEvent(KeyEvent.ACTION_DOWN, code)));
    }
    private String createKeyEvent(KeyEvent event) {
        JSONObject json = new JSONObject();
        try {
            json.put("Event", event.getKeyCode());
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return json.toString();
    }
    public class EventSender {
        private static final String TAG = "EventSender";
        private Socket mSocket;
        private String mDstAddress;
        private int mDstPort;
        private PrintWriter mPrintWriter;
        private EventSender(String dstAddress, int dstPort){
            Log.d(TAG, "EventSender");
            mDstAddress = dstAddress;
            mDstPort = dstPort;
            mSocket = new Socket();
        }
         public void println(String str){
            mPrintWriter.println(str);
        }
        public boolean close(){
            Log.d(TAG, "close()");
            if(mSocket != null){
                try {
                    mSocket.close();
                    mSocket = null;
                    return true;
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return false;
        }
        public boolean connect(){
            Log.d(TAG, "connect()");
            try {
                if (mSocket != null && !mSocket.isConnected()) {
                    Log.d(TAG, "new InetSocketAddress()");
                    mSocket.connect(new InetSocketAddress(mDstAddress, mDstPort));
                    mPrintWriter = new PrintWriter(mSocket.getOutputStream(), true);
                    mSocket.setKeepAlive(true);
                }
                return true;
                 }catch (IOException e) {
                e.printStackTrace();
            }
            return false;
        }
    }
}

服务器端：

public class ServerActivity extends Activity implements OnClickListener{
    private static final String TAG = "ServerActivity";
    private RemoteServer mRemoteServer;
    private EditText mServerPort;
    private TextView mServerRecEvent;
    private int keycode;
    private Instrumentation instrumentation;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
    StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()
                .detectDiskReads()
                .detectDiskWrites()
                .detectNetwork() 
                .penaltyLog() 
                .build());
        StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder()
                .detectLeakedSqlLiteObjects() 
                .penaltyLog() 
               .penaltyDeath()
                .build());
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_server);
        findViewById(R.id.ser_port_btn).setOnClickListener(this);
        mServerPort = (EditText) findViewById(R.id.ser_port_edi);
        mServerRecEvent = (TextView) findViewById(R.id.ser_recev_event);
    }
    @Override
    public void onClick(View v) {
        openServer(Integer.valueOf(mServerPort.getText().toString()));
    }
    public void openServer(int dstPort){
        Log.d(TAG, "openServer() - dstPort:" + dstPort);
        mServerRecEvent.setText("");
        if (mRemoteServer == null) {
            mRemoteServer = new RemoteServer(dstPort);
            if(mRemoteServer.openServer()) {
                mServerRecEvent.setText("服务启动成功！！！！/r/n");
            }
             Log.d(TAG, "openServer() - mRemoteServer:" + mRemoteServer);
        }
    }
    private void onEvent(String line) {
        Log.d(TAG, "line: " + line);

        try {
            JSONObject object=new JSONObject(line);
            keycode = (int) object.get("Event");
            Log.d(TAG, "keycode: " + keycode);
            if (instrumentation==null){
                instrumentation=new Instrumentation();
            }
            //通过KeyCode响应相应操作
            instrumentation.sendKeyDownUpSync(keycode);
            Log.d(TAG, "event key : " + keycode);
        } catch (JSONException e) {
   e.printStackTrace();
        }
        Message msg = Message.obtain();
        msg.what = 0;
        msg.obj = line;
        mHandler.sendMessage(msg);
   }
    private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            String text = mServerRecEvent.getText().toString();
            mServerRecEvent.setText(text + String.valueOf(msg.obj));
        }
    };


    class RemoteServer implements Runnable{
        private static final String TAG = "RemoteServer";
        private int mPort;
        private ServerSocket mServerSocket;
        private boolean mIsClose = false;
     public boolean isClose(){
            return mIsClose;
        }
        public boolean close(){
            try {
                mServerSocket.close();
                mServerSocket = null;
                mIsClose = true;
            } catch (IOException e) {
                e.printStackTrace();
            }
            return mIsClose;
        }
        public RemoteServer(int port){
            Log.d(TAG, "RemoteServer()");
            mPort = port;
        }
        public boolean openServer(){
            try {
                mServerSocket = new ServerSocket(mPort);
                new Thread(this).start();
                return true;
            } catch (IOException e) {
                e.printStackTrace();
            }
            return false;
        }
        public void run() {
            try {
                while (!mIsClose) {
                    Socket socket = mServerSocket.accept();
                    new ServerThread(socket);
                }
            } catch (IOException e) {
            }
        }
        private class ServerThread extends Thread {
            private Socket client;
            private BufferedReader in;
            public ServerThread(Socket s) throws IOException {
                client = s;
                in = new BufferedReader(new InputStreamReader(client.getInputStream()));
                start();
            }
            public void run() {
                android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_URGENT_DISPLAY);
                try {
                    String line = in.readLine();
                    while (!mIsClose) {
                        if(line != null){
                            onEvent(line);
                        }
                        line = in.readLine();
                    }
                    Log.d(TAG, "--- See you, bye! ---");
                 client.close();
                }
                catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

MainActivity

public class MainActivity extends Activity implements View.OnClickListener {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        findViewById(R.id.btn_client).setOnClickListener(this);
        findViewById(R.id.btn_server).setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.btn_client:
             startActivity(new Intent(this, ClientActivity.class));
                break;
            case R.id.btn_server:
                startActivity(new Intent(this, ServerActivity.class));
                break;
        }
    }
}

布局就不放了，有需要的可以看下实现过程，主要就是Socket通信，下面上界面，界面时测试界面，很丑，凑合着看吧：
首先在客户端和盒子上安装编译好的APP，在盒子端进入服务器端，输入端口号：img-w10
在手机端进入客户端，输入服务器端的IP地址和端口号：
img-w150
注意这里，连接成功时没有做判断，点击连接服务后，如果没反应即连接成功了。
还有：盒子和手机一定要在同一个局域网下！！！客户端输入的端口号和服务器输入的端口号一定要一致。

代码下载地址：http://download.csdn.net/download/json_jerry/9955125
本来想0积分提供，不知道为什么最低需要1积分。

Jay丶Xu
关注
专栏目录
Android TV 遥控器键值
08-22
Android 电视TV 遥控器键值对应表 互联网盒子 电视机顶盒
万字长文带你回顾电子游戏的七十多年历史（完整版）
热门推荐
OpenFPGA的博客
07-23 1万+
之前有很多人在后台说《从电子游戏历史看IC发展的助推剂》《80年代电子游戏及电脑游戏的发展历史》这两篇文章看的不是“太懂”，今天就把所有相关的资料都放出来，这样大家至少能把文章内容弄清楚，...
手机客户端控制互联网电视
文思er
07-01 2716
之前有个wifi-红外模块配置的事情由我来管，它用于互联网云电视的一个项目。由于以前的遥控设备里的wifi模块不稳定，经常出现断网情况，最近就新进了带有天线的wifi模块。于是我就来配置一下，顺便总结这方面的步骤，以妨时间久了遗忘。 首先来看一看新版的遥控器： 我上面标识的数字是引脚号，很重要，因为一旦配错了，就需要重新恢复成出厂设置，否则无法再次用手机连接它。由说明书就可知道给引脚3
android远程控制电视盒子,电视机顶盒远程遥控其实很简单 小白也能不在家帮爸妈遥控...
weixin_31991991的博客
05-26 9456
2019-9-23 17:03【天极网家电频道】智能手机的发展不断带动智能化家居的推进，现在家里不管是电视空调冰箱都要冠以“智能”之名。对于年轻人来说，学习一些智能设备新的用法一点不难，但是对于家人爸妈来说，学一个付款码操作可能就是极限了，更别提智能电视上的各种繁琐操作了。今天就为大家带来一个远程控制的攻略教程，这样就算不在家中，也可以轻松为家里的爸妈点播电影、电视剧观看。一、准备工作首先我们要在...
android电视手机控制器,智能电视控制器
weixin_42365141的博客
05-28 382
现在科技的发展非常强大，很多人都享受到了科技带来的好处，智能电视控制器这款app就是帮助用户们控制智能电视的软件，通过app就可以控制电视，相当于一个遥控器了，喜欢的朋友们快来聚侠网下载看看吧，非常实用哦。《智能电视控制器》软件特点：可以满足许多用户的操作需求，您就能通过手机进行更优质的操作了；满足众多用户的使用需求，是您在家看电视必备的工具；您只需要几个简单、便捷的操作，就能轻松的使用了；非常简...
手机UDP遥控飞机V1.0
weixin_42854045的博客
11-17 682
手机UDP遥控飞机V1.0
android手机遥控android机顶盒，实现鼠标、上下左右、震动软件
05-10
本文将详细解析如何使用Android手机作为遥控器来控制Android智能机顶盒，实现类似鼠标、上下左右移动以及震动功能，从而让手机成为机顶盒的全能控制器，特别适用于游戏和其他交互式应用。 首先，实现这一功能的关键...
基于Android系统的机顶盒及其摇控器的设计与实现
01-29
基于Android系统的机顶盒及其遥控器是以Android系统为平台开发一款硬件与软件相结合的产品，在传统机顶盒的基础上实现对电视和电脑屏幕的无线控制，最终实现三屏融合。不但能够利用当前Android移动终端自身强大的...
很经典的手机电视遥控器
05-11
可用于智能电视会机顶盒节目遥控的语音助手，分成两个部分，电视机/机顶盒上安装TV搬，手机上安装语音
android9.0ble补丁蓝牙语音遥控器支持补丁.rar
07-21
目前通过ble hal实现从hidraw中读取遥控器语音数据，在Android框架层上就通过配置文件将ble hal导入到音频框架中，并通过绑定Android原生已有的耳麦设备来完成audio音频策略选择，通过apk检测ble连接状态，通知audio...
Android 手机遥控器
08-29
Android 手机遥控器 ，手机遥控机顶盒，基于Socket的实现，博客地址：https://blog.csdn.net/Json_Jerry/article/details/77675990 希望能够帮助到你
ros安卓通过udp协议控制小车移动（实现手机端遥控器）
weixin_52602983的博客
03-29 1224
/ 接收消息的缓冲区。#define PORT 8000 // 用于监听的端口号。#define BUF_LEN 1024 // 缓冲区大小。//关闭socket。// 接收来自客户端的消息。// 向客户端发送回复消息。// 2.初始化 ROS 节点。// 4.循环发布运动控制消息。// 处理接收到的消息。// 初始化服务器地址结构体。// 绑定socket和地址。// 3.创建发布者对象。//4-2.设置发送频率。// 创建socket。//4-1.组织消息。//4-3.循环发送。
开源一个安卓四轴上位机+配套ESP8266 UDP串口通信源码
Kevincoooool
11-03 1万+
手机APP是由匿名四轴遥控器修改而来，在原有基础上添加了双摇杆控制和单摇杆控制 数据通过UDP和ESP8266通信 协议可修改 安卓app源码：https://github.com/Kevincoooool/KSTC_V1 ESP8266 串口通信固件源码：https://github.com/Kevincoooool/ESP8266_UART_UDP 安卓通过Android Studio 3.2...
自定义View的上下左右距离等解析
u010829459的博客
04-11 617
在自定义View时，经常会被各种top，bottom，x，rawX等绕晕，故将此记录下来，以备查看 其中 Rect frame = new Rect();   ((Activity)mContext).getWindow().getDecorView().getWindowVisibleDisplayFrame(frame);   int statusBarHeight = fra
Android 获取机顶盒遥控器键值
最新发布
gyf651194544的博客
05-26 639
adb shell然后开始按遥控器。
安卓Kotlin 代码模拟TV遥控点击上下左右事件
qq_40655872的博客
09-26 474
代码模拟tv遥控事件，无需root 根据坐标的点击： private fun click(x:Int,y:Int) { val order = listOf("input", "tap", "" + x, "" + y) ProcessBuilder(order).start() } xy代表坐标。 模拟遥控的keyevent： private fun leftclick(keyCode: In
Android 手机实现网络嗅探发现周围设备（类似悟空遥控器）
chixi8818的博客
06-11 1267
前几天接触过一个安卓手机遥控安卓电视的需求，需要完成局域网嗅探功能，搜索局域网内的电视设备，当时试着用socket连接轮流尝试，发现时间比较长，后来在网上发现一篇文章，用UDP实现这个功能，局域网广播的方式，效果不错，亲测可行，现贡献出代码。贴上后直接可以运行。 遥控器端代码： im...
微信小程序+UDP+wifi8266+l293d扩展板+Arduino uno遥控小车
lbttwo的博客
11-25 3209
微信小程序通过UDP遥控小车
Android Wifi连接控制、TCP、UDP通信，6.0以上适配
碎火流荧的博客
10-24 862
本文章包含内容 Wifi连接控制、Wifi广播接收，适配了Android6.0以上的版本 Wifi下的TCP通信 Wifi下的UDP通信 Github项目地址 码云项目地址 最近公司要开发智能家居，APP要作为遥控器和控制中心，其中的原理就是智能设备开机先作为一个热点，发射Wifi信号，然后手机连上这个热点（Wifi控制），手机和智能设备建立了连接后，将家里路由器wifi的账号密码通过TCP协议，Socket通信发送给智能设备，最后智能设备收到后就能连上家里的路由器了。 第一步当然就是Wifi控
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值