精华内容
下载资源
问答
  • DebugView, 可以很好的接收查看Windows打印消息,特别适合不方便调试的Release版本
  • iframe页: <iframe id="my-iframe" src="url"frameborder="no" width="100%" height="100%"></iframe> window.addEventListener('...注:如果打印结果为:[object Object],需使用JSON.stringify() 字符串化

    iframe页:

      <iframe id="my-iframe" src="url"frameborder="no" width="100%" height="100%"></iframe>
      	<script type="text/javascript">
         window.addEventListener('message',function(e){
    		 const da = e.data;
    		 console.log(da);
    		myFunction(da);
    	 });
    	 function myFunction(p1){
    		var result1 = p1;
    		console.table(result1);	
    		document.getElementById("demo").innerHTML = JSON.stringify(result1);
    	 }
    	</script>
    

    注:如果打印结果为:[object Object],需使用JSON.stringify() 字符串化

    展开全文
  • Android中监听通知消息的实现

    千次阅读 2018-09-04 15:24:41
    大致思路是在Android手机上安装一个程序,这个程序可以监听手机接收到的消息,然后打印出来,比如打印到logcat。经查,如果要实现这个功能,就要用到NotificationListenerService。 先看主程序: package c...

    由于自动化测试需要,我们希望能够监听Android手机中的推送消息来实现发送推送后的客户端自动检查。下面就来看看我们是如何实现客户端统计消息接收的。

    大致思路是在Android手机上安装一个程序,这个程序可以监听手机接收到的消息,然后打印出来,比如打印到logcat。经查,如果要实现这个功能,就要用到NotificationListenerService。

    先看主程序:

    package com.xingshulin.xsltestcontroller;
    
    import android.support.v7.app.ActionBarActivity;
    import android.text.TextUtils;
    import android.content.ComponentName;
    import android.content.Intent;
    import android.os.Bundle;
    import android.provider.Settings;
    import android.view.Menu;
    import android.view.MenuItem;
    import android.view.View;
    import android.view.View.OnClickListener;
    import android.widget.Button;
    import android.widget.Toast;
    
    public class MainActivity extends ActionBarActivity {
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            
            // 通知栏监控器开关
            Button notificationMonitorOnBtn = (Button)findViewById(R.id.notification_monitor_on_btn);
            notificationMonitorOnBtn.setOnClickListener(new OnClickListener() {
                @Override
                public void onClick(View v) {
                    // 
                    if (!isEnabled()) {
                        startActivity(new Intent("android.settings.ACTION_NOTIFICATION_LISTENER_SETTINGS"));
                    } else {
                        Toast toast = Toast.makeText(getApplicationContext(), "监控器开关已打开", Toast.LENGTH_SHORT);
                        toast.show();
                    }
                }
            });
            
            Button notificationMonitorOffBtn = (Button)findViewById(R.id.notification_monitor_off_btn);
            notificationMonitorOffBtn.setOnClickListener(new OnClickListener() {
                @Override
                public void onClick(View v) {
                    // 
                    if (isEnabled()) {
                        startActivity(new Intent("android.settings.ACTION_NOTIFICATION_LISTENER_SETTINGS"));
                    } else {
                        Toast toast = Toast.makeText(getApplicationContext(), "监控器开关已关闭", Toast.LENGTH_SHORT);
                        toast.show();
                    }
                }
            });
        }
        
        // 判断是否打开了通知监听权限
        private boolean isEnabled() {
            String pkgName = getPackageName();
            final String flat = Settings.Secure.getString(getContentResolver(), "enabled_notification_listeners");
            if (!TextUtils.isEmpty(flat)) {
                final String[] names = flat.split(":");
                for (int i = 0; i < names.length; i++) {
                    final ComponentName cn = ComponentName.unflattenFromString(names[i]);
                    if (cn != null) {
                        if (TextUtils.equals(pkgName, cn.getPackageName())) {
                            return true;
                        }
                    }
                }
            }
            return false;
        }
    
        @Override
        public boolean onCreateOptionsMenu(Menu menu) {
            // Inflate the menu; this adds items to the action bar if it is present.
            getMenuInflater().inflate(R.menu.main, menu);
            return true;
        }
    
        @Override
        public boolean onOptionsItemSelected(MenuItem item) {
            // Handle action bar item clicks here. The action bar will
            // automatically handle clicks on the Home/Up button, so long
            // as you specify a parent activity in AndroidManifest.xml.
            int id = item.getItemId();
            if (id == R.id.action_settings) {
                return true;
            }
            return super.onOptionsItemSelected(item);
        }
    
    }
    
    

    主程序很简单,就是安排两个按键,一个用来打开通知消息监听,一个用来关闭。点击打开监听按键后,如果之前并没有为APP打开过通知消息监听的权限,会跳转到通知消息监听权限界面,有个按钮会让你能打开权限。

    Screenshot_2016-09-18-14-49-29.jpeg

    实现就是程序中的:

    if (!isEnabled()) { 
           startActivity(new Intent("android.settings.ACTION_NOTIFICATION_LISTENER_SETTINGS"));
     }
    

    isEnabled()方法是用来判断通知消息监听权限是否已经打开了。方法中的"enabled_notification_listeners"为数据库字段,我们可以通过它的值来判断我们的APP是否有通知使用权。

    下面是关键的NotificationListenerService 的实现:

    package com.xingshulin.xsltestcontroller;
    
    import android.annotation.SuppressLint;
    import android.app.Notification;
    import android.os.Bundle;
    import android.service.notification.NotificationListenerService;
    import android.service.notification.StatusBarNotification;
    import android.util.Log;
    
    @SuppressLint("NewApi")
    public class NotificationMonitorService extends NotificationListenerService {
    
        // 在收到消息时触发
        @Override
        public void onNotificationPosted(StatusBarNotification sbn) {
            // TODO Auto-generated method stub
            Bundle extras = sbn.getNotification().extras;
            // 获取接收消息APP的包名
            String notificationPkg = sbn.getPackageName();
            // 获取接收消息的抬头
            String notificationTitle = extras.getString(Notification.EXTRA_TITLE);
            // 获取接收消息的内容
            String notificationText = extras.getString(Notification.EXTRA_TEXT);
            Log.i("XSL_Test", "Notification posted " + notificationTitle + " & " + notificationText);
        }
        
        // 在删除消息时触发
        @Override
        public void onNotificationRemoved(StatusBarNotification sbn) {
            // TODO Auto-generated method stub
            Bundle extras = sbn.getNotification().extras;
            // 获取接收消息APP的包名
            String notificationPkg = sbn.getPackageName();
            // 获取接收消息的抬头
            String notificationTitle = extras.getString(Notification.EXTRA_TITLE);
            // 获取接收消息的内容
            String notificationText = extras.getString(Notification.EXTRA_TEXT);
            Log.i("XSL_Test", "Notification removed " + notificationTitle + " & " + notificationText);
        }
    }
    

    有两个需要Override的方法,onNotificationPosted和onNotificationRemoved。
    onNotificationPosted是在接收到通知消息时触发
    onNotificationRemoved是在通知消息被删除时触发,比如通知栏中左划或右划消息。
    在方法中我们可以获取几乎所有消息的信息,如APP的包名,抬头和消息内容等。这些信息恰恰是我们做测试时需要判断的。

    最后是AndroidManifest.xml

    <?xml version="1.0" encoding="utf-8"?>
    <manifest xmlns:android="http://schemas.android.com/apk/res/android"
        package="com.xingshulin.xsltestcontroller"
        android:versionCode="1"
        android:versionName="1.0" >
        
        <uses-permission android:name="android.permission.WAKE_LOCK" />
        <uses-permission android:name="android.permission.DISABLE_KEYGUARD"/>
    
        <uses-sdk
            android:minSdkVersion="8"
            android:targetSdkVersion="21" />
    
        <application
            android:allowBackup="true"
            android:icon="@drawable/ic_launcher"
            android:label="@string/app_name"
            android:theme="@style/AppTheme" >
            <activity
                android:name=".MainActivity"
                android:label="@string/app_name" >
                <intent-filter>
                    <action android:name="android.intent.action.MAIN" />
                    <category android:name="android.intent.category.LAUNCHER" />
                </intent-filter>
            </activity>
           
            <service android:name=".NotificationMonitorService" 
                android:label="NotificationMonitor"
                android:permission="android.permission.BIND_NOTIFICATION_LISTENER_SERVICE">
                <intent-filter>
                    <action android:name="android.service.notification.NotificationListenerService" />
                </intent-filter>
            </service>
            
        </application>
    </manifest>
    
    

    这样,我们就可以通过这个APP获取通知消息的动作了,当然,我们同样也就可以只获得我们需要APP的消息了(通过在NotificationMonitorService 中过滤接收消息APP的包名):

    1.png

     

    展开全文
  • 这次结合打印解析监听程序消息链,为何打印、截图等需要开启着监听。 浏览器是BS的网页,打印截图等是CS程序,首先就不得不说到BS与CS交互的问题了。检验采用下图结构的多条通道进行尝试的模式交互。后期版本交互的...

    对检验系统来说,监听程序是什么?
    是仪器接口?
    是打印环境?
    是虚拟盒子?
    是导出环境?
    这次结合打印解析监听程序消息链,为何打印、截图等需要开启着监听。
    浏览器是BS的网页,打印截图等是CS程序,首先就不得不说到BS与CS交互的问题了。检验采用下图结构的多条通道进行尝试的模式交互。后期版本交互的关键就是WebSockt方式。
    在这里插入图片描述
    WebSockt的服务在哪里,当然寄宿在监听程序里面了。当然是为了客户端环境单一,其实可以寄宿在任意EXE里的,如下图,监听启动时候就把WebSockt服务起来了

    在这里插入图片描述
    以下才是本次分享的关键
    常规写法下在消息服务里收到消息后写死消息处理的逻辑不就完事了。如下面模式:

    socket.OnMessage = message =>
    {
    	//按message内容写处理逻辑就完事,分支多就来几个if判断
    }
    

    一旦按以上那么写了的话,那么消息作为通道的想法就没用了,有新业务需要借助消息就只能不断加入代码和判断处理,也使得消息不在单纯、稳定。
    为此:先抽离消息处理接口如下。

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using Fleck;
    
    namespace LIS.MsgCore
    {
        ///<summary  NoteObject="Class">
        /// [功能描述:消息处理接口,不同消息处理实现该接口] <para/>
        /// [创建者:zlz] <para/>
        /// [创建时间:2017年03月29日] <para/>
        ///<说明>
        ///  [说明:监听程序主窗口]<para/>
        ///</说明>
        ///<修改记录>
        ///    [修改时间:本次修改时间]<para/>
        ///    [修改内容:本次修改内容]<para/>
        ///</修改记录>
        ///<修改记录>
        ///    [修改时间:本次修改时间]<para/>
        ///    [修改内容:本次修改内容]<para/>
        ///</修改记录>
        ///</summary>
        public interface IMessageDeal
        {
            /// <summary>
            /// 处理消息
            /// </summary>
            /// <param name="socket">套接字,可以获得id,发送消息给socket</param>
            /// <param name="message">约定#分割的第一位描述消息类型,收到的消息内容</param>
            /// <returns>是否继续往后传递消息,true是,false否</returns>
            bool DealMessage(IWebSocketConnection socket,string message);
        }
    }
    
    

    然后再定义一个消息链对象用来支持配置消息处理链

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace LIS.MsgCore
    {
        ///<summary  NoteObject="Class">
        /// [功能描述:消息处理链] <para/>
        /// [创建者:zlz] <para/>
        /// [创建时间:2017年03月28日] <para/>
        ///<说明>
        ///  [说明:路径工具类,提供路径操作]<para/>
        ///</说明>
        ///<修改记录>
        ///    [修改时间:本次修改时间]<para/>
        ///    [修改内容:本次修改内容]<para/>
        ///</修改记录>
        ///<修改记录>
        ///    [修改时间:本次修改时间]<para/>
        ///    [修改内容:本次修改内容]<para/>
        ///</修改记录>
        ///</summary>
        public class MsgDealLink
        {
            /// <summary>
            /// 处理连接集合
            /// </summary>
            public List<IMessageDeal> LinkList
            {
                get;
                set;
            }
        }
    }
    
    

    然后消息服务收到消息后就只针对消息链的消息接口处理。调用消息链的每个对象来处理消息,直到返回false或者整个消息链都调完了,要点如下:
    在这里插入图片描述

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using LIS.MsgCore;
    using Fleck;
    using System.Timers;
    using System.Net.NetworkInformation;
    using System.Net;
    
    namespace LISMonitor
    {
        public class MessageServer
        {
            /// <summary>
            /// 改变图标委托
            /// </summary>
            public ExcCodeDelegate ChangeIcon
            {
                get;
                set;
            }
    
            /// <summary>
            /// 消息服务
            /// </summary>
            private static WebSocketServer server = null;
    
            /// <summary>
            /// 存所有套接字
            /// </summary>
            private static List<IWebSocketConnection> allSockets = new List<IWebSocketConnection>();
    
            /// <summary>
            /// 消息处理链对象
            /// </summary>
            MsgDealLink dealLinks = null;
    
            /// <summary>
            /// 定时器
            /// </summary>
            Timer timer = new Timer();
    
            /// <summary>
            /// 消息端口
            /// </summary>
            public int port=8082;
    
            /// <summary>
            /// 初始化消息服务
            /// </summary>
            /// <returns></returns>
            public string InitServer()
            {
                timer.Interval = 5000;
                timer.Elapsed += new ElapsedEventHandler(timer_Elapsed);
                //取消息链对象
                dealLinks = LIS.Core.Context.ObjectContainer.GetObject<MsgDealLink>();
                //检查端口占用
                bool isUse = PortInUse(port);
                if (isUse == true)
                {
                    port = 10210;
                    isUse=PortInUse(port);
                }
                if (isUse == true)
                {
                    port = 19910;
                    isUse = PortInUse(port);
                }
                if (isUse == true)
                {
                    port = 19902;
                    isUse = PortInUse(port);
                }
                if (isUse == true)
                {
    
                    return "8082端口和10210,19910,19902端口都被占用!无法启动消息服务!";
                }
                try
                {
                    server = new WebSocketServer("ws://127.0.0.1:" + port);
                    server.Start(socket =>
                    {
                        socket.OnOpen = () =>
                        {
                            //改变图标
                            if (ChangeIcon != null)
                            {
                                ChangeIcon("lm2");
                                timer.Start();
                            }
                            allSockets.Add(socket);
                            LIS.Core.Util.LogUtils.WriteDebugLog("#S消息服务打开连接:" + socket.ConnectionInfo.Id+socket.ConnectionInfo.Path);
                        };
                        socket.OnClose = () =>
                        {
                            //改变图标
                            if (ChangeIcon != null)
                            {
                                ChangeIcon("lm1");
                                timer.Start();
                            }
                            allSockets.Remove(socket);
                            LIS.Core.Util.LogUtils.WriteDebugLog("#S消息服务关闭连接:" + socket.ConnectionInfo.Id + socket.ConnectionInfo.Path);
                        };
                        socket.OnMessage = message =>
                        {
                            //改变图标
                            if (ChangeIcon != null)
                            {
                                ChangeIcon("msg");
                                timer.Start();
                            }
                            LIS.Core.Util.LogUtils.WriteDebugLog("#S消息服务收到消息:" + socket.ConnectionInfo.Id + socket.ConnectionInfo.Path + "内容:" + message);
                            LIS.Core.Util.LogUtils.WriteDebugLog("#S消息服务准备调用消息链...");
                            try
                            {
                                if (dealLinks != null && dealLinks.LinkList != null && dealLinks.LinkList.Count > 0)
                                {
                                    foreach (IMessageDeal deal in dealLinks.LinkList)
                                    {
                                        LIS.Core.Util.LogUtils.WriteDebugLog("#S调用:" + deal.GetType().FullName + "...");
                                        bool ret=deal.DealMessage(socket, message);
                                        LIS.Core.Util.LogUtils.WriteDebugLog("#S调用:" + deal.GetType().FullName + "结束...");
                                        //返回false不传递消息了
                                        if (ret == false)
                                        {
                                            LIS.Core.Util.LogUtils.WriteDebugLog("#S消息链不继续传递消息...");
                                            break;
                                        }
                                    }
                                }
                                LIS.Core.Util.LogUtils.WriteDebugLog("#S消息服务调用消息链结束...");
                            }
                            catch (Exception ex)
                            {
                                LIS.Core.Util.LogUtils.WriteExceptionLog("#S消息服务调用消息链异常", ex);
                            }
                            
                        };
                    });
                }
                catch (Exception ex)
                {
                    LIS.Core.Util.LogUtils.WriteExceptionLog("#S启动消息服务出错", ex);
                    return "#S启动消息服务出错:" + ex.Message+"调用堆栈:"+ex.StackTrace;
                }
                return "";
            }
    
            /// <summary>
            /// 判断端口是否被占用
            /// </summary>
            /// <param name="port">端口</param>
            /// <returns></returns>
            public bool PortInUse(int port)
            {
                bool inUse = false;
    
                IPGlobalProperties ipProperties = IPGlobalProperties.GetIPGlobalProperties();
                IPEndPoint[] ipEndPoints = ipProperties.GetActiveTcpListeners();
    
                foreach (IPEndPoint endPoint in ipEndPoints)
                {
                    if (endPoint.Port == port)
                    {
                        inUse = true;
                        break;
                    }
                }
                return inUse;
            }  
    
            /// <summary>
            /// 定时方法
            /// </summary>
            /// <param name="sender"></param>
            /// <param name="e"></param>
            public void timer_Elapsed(object sender, ElapsedEventArgs e)
            {
                //改变图标
                if (ChangeIcon != null)
                {
                    ChangeIcon("lm0");
                    timer.Stop();
                }
            }
        }
    }
    
    

    然后各种业务就只需要实现消息处理接口就行了。以打印、截图、编辑图片代码为例:
    打印

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.IO;
    using System.Diagnostics;
    using System.Net;
    using System.Management;
    using System.Xml;
    
    namespace LIS.MsgCore
    {
        /// <summary>
        /// 打印消息处理实现
        /// </summary>
        public class MessagePrintDeal:IMessageDeal
        {
            /// <summary>
            /// 处理消息
            /// </summary>
            /// <param name="socket">套接字,可以获得id,发送消息给socket</param>
            /// <param name="message">约定#分割的第一位描述消息类型,收到的消息内容</param>
            /// <returns>是否继续往后传递消息,true是,false否</returns>
            public bool DealMessage(Fleck.IWebSocketConnection socket, string message)
            {
                LIS.Core.Util.LogUtils.WriteDebugLog("识别以print#开头的消息");
                //识别打印消息
                if (message.Split('#')[0] == "print")
                {
                    LIS.Core.Util.LogUtils.WriteDebugLog("确定为打印消息,准备处理");
                    int index = message.IndexOf('#');
                    string msg = message.Substring(index+1);
                    string [] arrMsg=msg.Split('@');
                    //清除历史数据命令拦截
                    if (arrMsg.Length == 2 && arrMsg[0].Contains("ClearHistory"))
                    {
                        LIS.Core.Util.LogUtils.WriteDebugLog("拦截到清除缓存消息");
                        string chromePath = "";
                        bool IsChrome = SubKeyOperation.TryGetSoftwarePath("chrome", out chromePath);
                        if (IsChrome && chromePath.Length > 0)
                        {
                            DirectoryInfo di = new DirectoryInfo(chromePath);
                            string cachePath = di.Parent.Parent.FullName + "\\User Data\\";
                            DeleteFile(cachePath + "Default\\Cache", "");
                            DeleteFile(cachePath + "Profile 1\\Cache", "");
                            DeleteFile(cachePath + "Profile 2\\Cache", "");
                            DeleteFile(cachePath + "Profile 3\\Cache", "");
                            DeleteFile(cachePath + "Profile 4\\Cache", "");
                            DeleteFile(cachePath + "Profile 5\\Cache", "");
                            DeleteFile(cachePath + "Profile 6\\Cache", "");
                            DeleteFile(cachePath + "Profile 7\\Cache", "");
                            DeleteFile(cachePath + "Profile 8\\Cache", "");
                        }
                        //更新TRAK
                        if (arrMsg[1] != "")
                        {
                            if (System.IO.File.Exists(@"C:\TRAK\LISUpGrade.exe"))
                            {
                                Process.Start(@"C:\TRAK\LISUpGrade.exe", arrMsg[1]);
                            }
                        }
                        return false;
                    }
                    //报告打印消息直接处理,不驱动exe,提高速度
                    if (arrMsg.Length > 5 && (!arrMsg[4].Contains("PDF#")) && (arrMsg[0] == "iMedicalLIS://0" || arrMsg[0] == "iMedicalLIS://1") && (arrMsg[4] != "ReportView"))
                    {
                        string cmdLine = msg.Substring(14);
                        string[] tmpStrings = cmdLine.Split((char)64);
                        string printFlag = tmpStrings[0];
                        string connectString = tmpStrings[1].Replace("&", "&amp;");
                        if (System.IO.File.Exists("C:\\TRAK\\ResultPrint.exe.config"))
                        {
                            XmlDocument doc = new XmlDocument();
                            doc.Load("C:\\TRAK\\ResultPrint.exe.config");
                            //找出名称为“add”的所有元素  
                            XmlNodeList nodes = doc.GetElementsByTagName("add");
                            for (int i = 0; i < nodes.Count; i++)
                            {
                                //获得将当前ConfDataCode属性  
                                XmlAttribute attConf = nodes[i].Attributes["key"];
                                //根据元素的第一个属性来判断当前的元素是不是目标元素  
                                if (attConf != null && attConf.Value == "WebServiceAddressOne")
                                {
                                    attConf = nodes[i].Attributes["value"];
                                    if(attConf.Value!=null&&attConf.Value!="")
                                    {
                                        connectString = attConf.Value;
                                    }
                                }
                            }
                        }
                        string rowids = tmpStrings[2];
                        string userCode = tmpStrings[3];
                        //PrintOut:打印  PrintPreview打印预览
                        string printType = tmpStrings[4];
                        //参数
                        string paramList = tmpStrings[5];    ///模块名称(LIS工作站,DOC医生,SELF自助,OTH其它)
    
                        string clsName = "";
                        string funName = "";
                        if (tmpStrings.Length >= 8)
                        {
                            clsName = tmpStrings[6];
                            funName = tmpStrings[7];
                        }
    
                        //没传报告主键退出
                        if (rowids == "" && printType != "ReportView")
                        {
                            LIS.Core.Util.LogUtils.WriteDebugLog("未传入报告主键");
                            return true;
                        };
                        string ip = "";
                        string hostName = Dns.GetHostName();  //本机名
                        System.Net.IPAddress[] addressList = Dns.GetHostEntry(Dns.GetHostName()).AddressList;
                        for (int i = 0; i < addressList.Length; i++)
                        {
                            ip = addressList[i].ToString();
                        }
    
                        string mac = "";
                        //部分电脑有问题
                        //ManagementClass mc = new ManagementClass("Win32_NetworkAdapterConfiguration");
                        //ManagementObjectCollection moc = mc.GetInstances();
                        //foreach (ManagementObject mo in moc)
                        //{
                        //    if (mo["IPEnabled"].ToString() == "True")
                        //    {
                        //        mac = mo["MacAddress"].ToString();
                        //    }
                        //}
                        paramList = paramList + "^HN" + hostName + "^IP" + ip + "^MAC" + mac;
                        //printFlag  0:打印所有报告 1:循环打印每一份报告
                        if (printFlag.Substring(0, 1) == "0")
                        {
                            DHCLabtrakReportPrint.ReportAccess reportPrint = new DHCLabtrakReportPrint.ReportAccess(rowids, userCode, paramList, connectString, printType, clsName, funName);
                        }
                        else
                        {
                            string[] tmpRowids = rowids.Split((char)94);
                            for (int i = 0; i < tmpRowids.Length; i++)
                            {
                                rowids = tmpRowids[i];
                                if (rowids != "")
                                {
                                    DHCLabtrakReportPrint.ReportAccess reportPrint = new DHCLabtrakReportPrint.ReportAccess(rowids, userCode, paramList, connectString, printType, clsName, funName);
                                }
                            }
                        }
                    }
                    else
                    {
                        if (System.IO.File.Exists(@"C:\TRAK\ResultPrint.exe"))
                        {
    
                            LIS.Core.Util.LogUtils.WriteDebugLog("调用打印程序");
                            System.Diagnostics.Process.Start(@"C:\TRAK\ResultPrint.exe", msg.Replace("\"", "\\\"").Replace("+", "%2B"));
                        }
                        else
                        {
                            LIS.Core.Util.LogUtils.WriteDebugLog(@"C:\TRAK\ResultPrint.exe");
                        }
                    }
                    LIS.Core.Util.LogUtils.WriteDebugLog("处理完成,截断消息链");
                    return false;
                }
                LIS.Core.Util.LogUtils.WriteDebugLog("不是打印消息,传递消息链");
                return true;
            }
    
            /// <summary>
            /// 删除指定目录指定后缀名的文件
            /// </summary>
            /// <param name="path"></param>
            /// <param name="extend"></param>
            private void DeleteFile(string path, string extend)
            {
                if (Directory.Exists(path))
                {
                    DirectoryInfo di = new DirectoryInfo(path);
                    FileInfo[] files = di.GetFiles();
                    if (files != null && files.Length > 0)
                    {
                        foreach (var v in files)
                        {
                            try
                            {
                                if (v.Extension == extend)
                                {
                                    System.IO.File.Delete(v.FullName);
                                }
                            }
                            catch
                            {
                            }
                        }
                    }
                }
            }
        }
    }
    
    

    截图

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.IO;
    using System.Diagnostics;
    using System.Windows.Forms;
    using LISScreenCapture;
    
    namespace LIS.MsgCore
    {
        /// <summary>
        /// 捕获图片消息处理实现
        /// </summary>
        public class MessageGetImageCommon : IMessageDeal
        {
            /// <summary>
            /// 当前消息
            /// </summary>
            private string curMsg;
    
            /// <summary>
            /// 当前端口
            /// </summary>
            private Fleck.IWebSocketConnection curSocket;
    
            /// <summary>
            /// 处理消息
            /// </summary>
            /// <param name="socket">套接字,可以获得id,发送消息给socket</param>
            /// <param name="message">约定#分割的第一位描述消息类型,收到的消息内容</param>
            /// <returns>是否继续往后传递消息,true是,false否</returns>
            public bool DealMessage(Fleck.IWebSocketConnection socket, string message)
            {
                LIS.Core.Util.LogUtils.WriteDebugLog("识别以getimage#开头的消息");
                //识别打印消息
                if (message.Split('#')[0] == "getimage")
                {
                    LIS.Core.Util.LogUtils.WriteDebugLog("确定为捕获图片消息,准备处理");
                    int index = message.IndexOf('#');
                    string msg = message.Substring(index+1);
                    if (msg.Contains("#Capture"))
                    {
                        msg = msg.Replace("#Capture", "");
                        curMsg = msg;
                        curSocket = socket;
                        MethodInvoker mi = new MethodInvoker(this.ShowCaptureForm);
                        Application.OpenForms["FrmMian"].BeginInvoke(mi);
                    }
                    else
                    {
                        curMsg = msg;
                        if (curMsg.Length > 0)
                        {
                            if (curMsg.Substring(curMsg.Length - 1) == "#")
                            {
                                curMsg = curMsg.Substring(0, curMsg.Length - 1);
                            }
                        }
                        curSocket = socket;
                        MethodInvoker mi = new MethodInvoker(this.ShowForm);
                        Application.OpenForms["FrmMian"].BeginInvoke(mi);
                    }
                    LIS.Core.Util.LogUtils.WriteDebugLog("处理完成,截断消息链");
                    return false;
                }
                LIS.Core.Util.LogUtils.WriteDebugLog("不是捕获图片消息,传递消息链");
                return true;
            }
    
            /// <summary>
            /// 显示窗口
            /// </summary>
            private void ShowForm()
            {
                FrmGetImage frm = new FrmGetImage();
                frm.Ftp = curMsg;
                frm.Socket = curSocket;
                frm.ShowDialog();
            }
    
            /// <summary>
            /// 显示窗口
            /// </summary>
            private void ShowCaptureForm()
            {
                FrmCaptureReportImg frmC = new FrmCaptureReportImg();
                frmC.Ftp = curMsg;
                frmC.Socket = curSocket;
                frmC.ShowDialog();
            }  
        }
    }
    
    

    编辑图片

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.IO;
    using System.Diagnostics;
    using LISScreenCapture;
    using System.Drawing;
    using System.Windows.Forms;
    
    namespace LIS.MsgCore
    {
        /// <summary>
        /// 编辑图片消息处理
        /// </summary>
        public class MessageEditImageDeal : IMessageDeal
        {
            /// <summary>
            /// 消息接口
            /// </summary>
            private Fleck.IWebSocketConnection cursocket = null;
    
            /// <summary>
            /// 窗口
            /// </summary>
            CutBord frm = null;
    
            /// <summary>
            /// 处理消息
            /// </summary>
            /// <param name="socket">套接字,可以获得id,发送消息给socket</param>
            /// <param name="message">约定#分割的第一位描述消息类型,收到的消息内容</param>
            /// <returns>是否继续往后传递消息,true是,false否</returns>
            public bool DealMessage(Fleck.IWebSocketConnection socket, string message)
            {
                LIS.Core.Util.LogUtils.WriteDebugLog("识别以editimage#开头的消息");
                //识别编辑图片消息
                if (message.Split('#')[0] == "editimage")
                {
                    LIS.Core.Util.LogUtils.WriteDebugLog("确定为编辑图片消息,准备处理");
                    int index = message.IndexOf('#');
                    cursocket = socket;
                    string msg = message.Substring(index + 1);
                    frm = new CutBord();
                    frm.Path = msg;
                    frm.SaveCallBack = new SaveCallback(SaveImg);
                    MethodInvoker mi = new MethodInvoker(this.ShowForm);
                    Application.OpenForms["FrmMian"].BeginInvoke(mi);
                    LIS.Core.Util.LogUtils.WriteDebugLog("处理完成,截断消息链");
                    return false;
                }
                LIS.Core.Util.LogUtils.WriteDebugLog("不是编辑图片消息,传递消息链");
                return true;
            }
    
            /// <summary>
            /// 显示窗口
            /// </summary>
            private void ShowForm()
            {
                frm.TopMost = true;
                frm.ShowDialog();
            }
    
            /// <summary>
            /// 保存图片
            /// </summary>
            /// <param name="img">图片</param>
            /// <param name="path">路径</param>
            public void SaveImg(Bitmap img, string path)
            {
                if (MessageBox.Show("是否要保存修改到服务器?", "提示", MessageBoxButtons.OKCancel, MessageBoxIcon.Information) == DialogResult.OK)
                {
                    Upload(img, path);
                }
            }
    
            /// <summary>
            /// 上传图片
            /// </summary>
            /// <param name="img">图片</param>
            /// <param name="path">路径</param>
            public void Upload(Bitmap img, string path)
            {
                Stream stream = new MemoryStream();
                System.Drawing.Imaging.ImageFormat format = System.Drawing.Imaging.ImageFormat.Bmp;
                //扩展名
                string aLastName = path.Substring(path.LastIndexOf(".") + 1);
                aLastName = aLastName.ToUpper();
                if (aLastName == "JPG")
                {
                    format = System.Drawing.Imaging.ImageFormat.Jpeg;
                }
                else if (aLastName == "EMF")
                {
                    format = System.Drawing.Imaging.ImageFormat.Emf;
                }
                else if (aLastName == "EXIF")
                {
                    format = System.Drawing.Imaging.ImageFormat.Exif;
                }
                else if (aLastName == "GIF")
                {
                    format = System.Drawing.Imaging.ImageFormat.Gif;
                }
                else if (aLastName == "ICON")
                {
                    format = System.Drawing.Imaging.ImageFormat.Icon;
                }
                else if (aLastName == "JPEG")
                {
                    format = System.Drawing.Imaging.ImageFormat.Jpeg;
                }
                else if (aLastName == "PNG")
                {
                    format = System.Drawing.Imaging.ImageFormat.Png;
                }
                else if (aLastName == "TIFF")
                {
                    format = System.Drawing.Imaging.ImageFormat.Tiff;
                }
                else if (aLastName == "WMF")
                {
                    format = System.Drawing.Imaging.ImageFormat.Wmf;
                }
                try
                {
                    img.Save(stream, format);
                    LIS.File.Core.FileService fileService = new File.Core.FileService();
                    fileService.Upload(path.Substring(0, path.LastIndexOf("/") + 1), stream, path.Substring(path.LastIndexOf("/") + 1), "");
                    stream.Close();
                    cursocket.Send("1");
                }
                catch (Exception ex)
                {
                    MessageBox.Show("保存失败:" + ex.Message, "提示", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }
        }
    }
    
    

    然后把消息处理实现类配置到消息链对象即可,依赖容器配置,也能自己反射
    在这里插入图片描述

    至此一个有充分开放性的消息链通道就开发完成了。使得监听具有不光是检验打印的监听,也能是截图的监听,也能是编辑文件的、CA的等等,也能是非检验的BS-CS交互通道,只需要你使用消息处理接口配置到消息链中。这就是设计模式带来的魅力。

    展开全文
  • <div><p>根据官方的readme里面说到的应用内监听 NativeAppEventEmitter.addListener( 'networkDidReceiveMessage', (message) => console.log(message) ); 应用在前台,日志打印不出来,请问什么问题...
  • springboot整合RabbitMQ时,监听消息: @Service public class BookService { @RabbitListener(queues = "gulixueyuan.news") public void receive(Book book){ System.out.println("收到消息"+book); } } ...

    springboot整合RabbitMQ时,监听消息:

    @Service
    public class BookService {
    
        @RabbitListener(queues = "gulixueyuan.news")
        public void receive(Book book){
            System.out.println("收到消息"+book);
        }
    
    }
    

    打印的消息:
    在这里插入图片描述
    当时还是懵逼了一下,打印的是
    收到消息com.atguigu.amqp.bean.Book@7cd22e50
    后来发现,实体类中没有toString方法,不能显示具体信息,加上方法:

        @Override
        public String toString() {
            return "Book{" +
                    "bookName='" + bookName + '\'' +
                    ", author='" + author + '\'' +
                    '}';
        }
    

    在这里插入图片描述
    粗心了呀

    展开全文
  • 在自定义消息监听器中能收到 JPushModule.addReceiveCustomMsgListener((map) => { console.log("receive CustomMsg: "); console.log(map); console.log("extras: " + map.extras...
  • 大家好,我是SKODE。 小提示:选中左侧目录,可快速找到所需内容 本系列博客地址:传送门 一、Back Button ...Debug Mode:调试模式–使相关的调试消息能够打印到控制台 Input Mode:输入模式。包含如下...
  • ,当打印的时候就可以知道当前在分发mH 类的任何消息。 但是对方说,不希望在这里拦截,有没有其他方法,当时没有想到Handler 有什么可以设置监听每一个消息的方法,就算有,我如果想要拿到mH 也得通过反射吧。当时
  • JMS和消息驱动Bean(MDB)

    2019-07-07 13:51:06
    本示例使用的ActiveMQ作为消息中间件,服务器为Glassfish,使用JMS发送消息,在MDB接收到消息之后做打印输出。 二、ActiveMQ安装配置 1、安装console war包安装到服务器不需要特殊配置,默认监听端口为61616,可...
  • 然后在service的方法上书写@RabbitListener注解,通过属性queues来指定需要监听的队列,当springboot启动类启动时,只要队列中有消息,该注解标注的方法就会自动的将消息打印在控制台: @Service public class ...
  • MQ服务消息队列介绍

    2010-11-30 16:36:57
    则会在屏幕上打印出刚才输入的字符数据消息。暂停后,;例子程序结束。 如果以上步骤都能够完成,则完成了MQ服务端和客户端的互联配置。 注意:有时候,MQ客户端联服务端时会因为两端字符集编码CCSID不一样造成...
  • 我用java socket写了一个监听端口,接收到数据就会返回一个字符串。我现在想在web网页端做一个按钮,一按就向服务端请求并将返回字符串打印在屏幕上,这个应该如何实现?我试过用javascript的websocket,可是行不通...
  • 第三次:ReceiveJms:iljlkjkl依次递增打印 而把 java:comp/env/jms/JMSChat换为java:comp/env/jms/Queue 的点对点配置没错 就是topic方式是出现这问题 [b]问题补充:[/b] 我在另一个应用B里配置了同样的代码,都...
  • xmpp授权登陆步骤1 初始化xmppstream 连接服务器 传递属性jid(IP地址 端口号)2 连接成功后 传递“登”陆密码授权 3 授权后,发送在线消息xmpp所有的代理都是子线程中调用的,处理ui操作需手动在主线...监听连接状态...
  • <div><p>接收微信voice类型消息,在微信公众平台后台开启“语音识别功能”后,可以看到返回数据里面有Recognition字段,但是值总是为空。 <p>----------------------app里面代码-----------------...
  • 7、Spring Integration RabbitMQ

    千次阅读 2018-08-14 23:42:10
    经过前面的教程我们知道了 RabbitMQ 里面的基本的队列消息发送,以及不同类型的交换器的消息发送。今天就来分享一下 RabbitMQ ...然后使用监听打印获取到的消息。 fanout(扇形)交换器类型的消息,也就是发布/订阅...
  • 刚学这个,写的可能不够规范,如果有错误还请指出 ...一个负责监听来自客户端的连接 一个负责随时收到客户端的消息 具体实现看代码 #include <iostream> #include <string> #include <t
  • Python使用Socket写一个聊天程序

    千次阅读 2018-03-25 22:52:10
    方法:客户端1:获取发送信息的地址和端口,然后发送给对方的服务端2,服务端2监听所有地址来的固定端口的消息,然后将消息打印出来 然后回复一条给客户端1说收到了。客户端1可以继续向服务端2发送消息。 客户端...
  • Java UDP使用Socket进行网络聊天(1)

    千次阅读 2014-09-16 09:30:13
    本文演示,使用Socket进行网络聊天,实现客户端给服务器端一直发送消息,当发送“886”的时候,表示客户端关闭。 1)客户端,给服务器发送数据,发送...2)服务器,一直监听9527端口,将监听到的数据打印在控制台上。
  • # btcpool矿池-JobMaker模块解析## 核心机制总结* 同时监听kafka KAFKA_TOPIC_RAWGBT和KAFKA_TOPIC_NMC_AUXBLOCK,以支持混合挖矿* 接收的Gbt消息,如果与本地时间延迟超过60秒将丢弃,如果延迟超过3秒将打印log* ...
  • iOS通知的例子

    2019-03-13 17:21:49
    通知是iOS中的一种消息传递方式,通过消息中心(NSNotificationCenter)对消息监听,当某些类发送出消息的时候,消息中心监听到这些消息,然后进行相应的操作,这些操作对于发送出这些消息的类来说是相同的。...
  • 使用场景:微信打印照片业务中,将用户待打印的图片放到队列中(生产者生产消息),然后本地机器上的服务监听某个消息(消费者消费消息),调用打印服务。 1: ...
  • 问题: ...当server监听着,client第一次发送消息成功,server接收并打印出来了。 client第二次发送消息没成功并且结束程序了,server没接收到消息,保持继续监听。 我用GDB调试时,发现client第...
  • 续 Springboot+WebSocket+RabbitMQ

    千次阅读 2018-11-16 10:06:06
    今天给大家修复一下,上一篇文章因为博主的业务需求需要,本人将websocket的服务端和rabbitmq的监听消费端整合在了一起,结果出来了一个意想不到的结果,程序后台控制台一直不停地打印消息,重复地接受前台和队列发...
  • 消费者监听队列,监听到消息后打印消息主体(id) 1. 创建项目导入依赖 1.1 创建项目 我创建的是maven项目,父项目是rabbitMQ,子项目是provider提供者和consumer消费者。 1.2 导入依赖 导入依赖,最开始我是在...
  • 客户端发送广播,开启端口监听的服务端接收并打印消息 服务端程序: import java.io.IOException; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.SocketException; ...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 212
精华内容 84
关键字:

打印消息监听