예제 #1
0
        public void Reset()
        {
            mOfflineRequestQueue.Clear();

            lock ( noteLock )
            {
                currentNote = null;
            }
        }
예제 #2
0
        /// <summary>
        /// Request offline data of pen.
        /// When you request offline data, your request is inserted to queue.
        /// </summary>
        /// <param name="notes">array of OfflineNote object</param>
        public void ReqOfflineData(OfflineDataInfo note)
        {
            System.Console.WriteLine("ReqOfflineData ( result : {0} )", note.ToString());

            if (note == null)
            {
                return;
            }

            if (IsV1Comm)
            {
                mCommV1.ReqOfflineData(note);
            }
            else
            {
                mCommV2.ReqOfflineData(note.Section, note.Owner, note.Note, false, note.Pages);
            }
        }
예제 #3
0
        private void RequestNote()
        {
            while (isRun)
            {
                if (mOfflineRequestQueue.Count() > 0)
                {
                    lock ( noteLock )
                    {
                        currentNote = mOfflineRequestQueue.Peek();

                        Debug.WriteLine("[OfflineWorker] start download offline note => sectionId : " + currentNote.Section + ", ownerId : " + currentNote.Owner + ", noteId : " + currentNote.Note);

                        // 데이터 전송을 요청한다.
                        mHandler.onRequestDownloadOfflineData(currentNote.Section, currentNote.Owner, currentNote.Note);
                    }
                }

                {
                    lockHandleRequest.WaitOne();
                }
            }
        }
예제 #4
0
        public void onFinishDownload()
        {
            if (currentNote == null)
            {
                return;
            }

            if (currentNote.Section != 4)
            {
                mHandler.onRequestRemoveOfflineData(4, currentNote.Note);
            }

            lock ( noteLock )
            {
                currentNote = null;
            }

            mOfflineRequestQueue.Dequeue();

            lock ( lockHandleRequest )
            {
                lockHandleRequest.Set();
            }
        }
예제 #5
0
 public void Put(OfflineDataInfo note)
 {
     Put(new OfflineDataInfo[] { note });
 }
예제 #6
0
        /// <summary>
        /// Requests the transmission of data
        /// </summary>
        /// <param name="note">A OfflineDataInfo that specifies the information for the offline data.</param>
        /// <returns>true if the request is accepted; otherwise, false.</returns>
        public bool ReqOfflineData(OfflineDataInfo note)
        {
            mOfflineworker.Put(note);

            return(true);
        }
예제 #7
0
        public void ParsePacket(Packet packet)
        {
            Cmd cmd = (Cmd)packet.Cmd;

            //Debug.Write("Cmd : {0}", cmd.ToString());

            switch (cmd)
            {
            case Cmd.VERSION_RESPONSE:
            {
                DeviceName      = packet.GetString(16);
                FirmwareVersion = packet.GetString(16);
                ProtocolVersion = packet.GetString(8);
                SubName         = packet.GetString(16);
                DeviceType      = packet.GetShort();
                MaxForce        = -1;
                MacAddress      = BitConverter.ToString(packet.GetBytes(6)).Replace("-", "");

                IsUploading = false;

                ReqPenStatus();
            }
            break;

                #region event
            case Cmd.SHUTDOWN_EVENT:
            {
                byte reason = packet.GetByte();
                Debug.Write(" => SHUTDOWN_EVENT : {0}", reason.ToString());
            }
            break;

            case Cmd.LOW_BATTERY_EVENT:
            {
                int battery = (int)(packet.GetByte() & 0xff);

                PenController.onReceiveBatteryAlarm(new BatteryAlarmReceivedEventArgs(battery));
            }
            break;

            case Cmd.ONLINE_PEN_UPDOWN_EVENT:
            case Cmd.ONLINE_PEN_DOT_EVENT:
            case Cmd.ONLINE_PAPER_INFO_EVENT:
            {
                ParseDotPacket(cmd, packet);
            }
            break;
                #endregion

                #region setting response
            case Cmd.SETTING_INFO_RESPONSE:
            {
                // 비밀번호 사용 여부
                bool lockyn = packet.GetByteToInt() == 1;

                // 비밀번호 입력 최대 시도 횟수
                int pwdMaxRetryCount = packet.GetByteToInt();

                // 비밀번호 입력 시도 횟수
                int pwdRetryCount = packet.GetByteToInt();

                // 1970년 1월 1일부터 millisecond tick
                long time = packet.GetLong();

                // 사용하지 않을때 자동으로 전원이 종료되는 시간 (단위:분)
                short autoPowerOffTime = packet.GetShort();

                // 최대 필압
                short maxForce = packet.GetShort();

                // 현재 메모리 사용량
                int usedStorage = packet.GetByteToInt();

                // 펜의 뚜껑을 닫아서 펜의 전원을 차단하는 기능 사용 여부
                bool penCapOff = packet.GetByteToInt() == 1;

                // 전원이 꺼진 펜에 필기를 시작하면 자동으로 펜의 켜지는 옵션 사용 여부
                bool autoPowerON = packet.GetByteToInt() == 1;

                // 사운드 사용여부
                bool beep = packet.GetByteToInt() == 1;

                // 호버기능 사용여부
                bool hover = packet.GetByteToInt() == 1;

                // 남은 배터리 수치
                int batteryLeft = packet.GetByteToInt();

                // 오프라인 데이터 저장 기능 사용 여부
                bool useOffline = packet.GetByteToInt() == 1;

                // 필압 단계 설정 (0~4) 0이 가장 민감
                short fsrStep = (short)packet.GetByteToInt();

                // 최초 연결시
                if (MaxForce == -1)
                {
                    MaxForce = maxForce;

                    var connectedEventArgs = new ConnectedEventArgs();

                    PenController.onConnected(new ConnectedEventArgs(MacAddress, DeviceName, FirmwareVersion, ProtocolVersion, SubName, MaxForce));
                    PenMaxForce = MaxForce;

                    if (lockyn)
                    {
                        // TODO 여기서 부터 시작
                        PenController.onPenPasswordRequest(new PasswordRequestedEventArgs(pwdRetryCount, pwdMaxRetryCount));
                    }
                    else
                    {
                        PenController.onPenAuthenticated();
                    }
                }
                else
                {
                    PenController.onReceivePenStatus(new PenStatusReceivedEventArgs(lockyn, pwdMaxRetryCount, pwdRetryCount, time, autoPowerOffTime, MaxForce, batteryLeft, usedStorage, useOffline, autoPowerON, penCapOff, hover, beep, fsrStep));
                }
            }
            break;

            case Cmd.SETTING_CHANGE_RESPONSE:
            {
                int inttype = packet.GetByteToInt();

                SettingType stype = (SettingType)inttype;

                bool result = packet.Result == 0x00;

                switch (stype)
                {
                case SettingType.AutoPowerOffTime:
                    PenController.onPenAutoShutdownTimeSetupResponse(new SimpleResultEventArgs(result));
                    break;

                case SettingType.AutoPowerOn:
                    PenController.onPenAutoPowerOnSetupResponse(new SimpleResultEventArgs(result));
                    break;

                case SettingType.Beep:
                    PenController.onPenBeepSetupResponse(new SimpleResultEventArgs(result));
                    break;

                case SettingType.Hover:
                    PenController.onPenHoverSetupResponse(new SimpleResultEventArgs(result));
                    break;

                case SettingType.LedColor:
                    PenController.onPenColorSetupResponse(new SimpleResultEventArgs(result));
                    break;

                case SettingType.OfflineData:
                    PenController.onPenOfflineDataSetupResponse(new SimpleResultEventArgs(result));
                    break;

                case SettingType.PenCapOff:
                    PenController.onPenCapPowerOnOffSetupResponse(new SimpleResultEventArgs(result));
                    break;

                case SettingType.Sensitivity:
                    PenController.onPenSensitivitySetupResponse(new SimpleResultEventArgs(result));
                    break;

                case SettingType.Timestamp:
                    PenController.onPenTimestampSetupResponse(new SimpleResultEventArgs(result));
                    break;
                }
            }
            break;
                #endregion

                #region password response
            case Cmd.PASSWORD_RESPONSE:
            {
                int status   = packet.GetByteToInt();
                int cntRetry = packet.GetByteToInt();
                int cntMax   = packet.GetByteToInt();

                if (status == 0)
                {
                    PenController.onPenPasswordRequest(new PasswordRequestedEventArgs(cntRetry, cntMax));
                }
                else
                {
                    PenController.onPenAuthenticated();
                }
            }
            break;

            case Cmd.PASSWORD_CHANGE_RESPONSE:
            {
                int cntRetry = packet.GetByteToInt();
                int cntMax   = packet.GetByteToInt();

                PenController.onPenPasswordSetupResponse(new SimpleResultEventArgs(packet.Result == 0x00));
            }
            break;
                #endregion

                #region offline response
            case Cmd.OFFLINE_NOTE_LIST_RESPONSE:
            {
                short length = packet.GetShort();

                List <OfflineDataInfo> result = new List <OfflineDataInfo>();

                for (int i = 0; i < length; i++)
                {
                    byte[] rb = packet.GetBytes(4);

                    int section = (int)(rb[3] & 0xFF);
                    int owner   = ByteConverter.ByteToInt(new byte[] { rb[0], rb[1], rb[2], (byte)0x00 });
                    int note    = packet.GetInt();

                    result.Add(new OfflineDataInfo(section, owner, note));
                }

                PenController.onReceiveOfflineDataList(new OfflineDataListReceivedEventArgs(result.ToArray()));
            }
            break;

            case Cmd.OFFLINE_PAGE_LIST_RESPONSE:
            {
                byte[] rb = packet.GetBytes(4);

                int section = (int)(rb[3] & 0xFF);
                int owner   = ByteConverter.ByteToInt(new byte[] { rb[0], rb[1], rb[2], (byte)0x00 });
                int note    = packet.GetInt();

                short length = packet.GetShort();

                int[] pages = new int[length];

                for (int i = 0; i < length; i++)
                {
                    pages[i] = packet.GetInt();
                }

                OfflineDataInfo info = new OfflineDataInfo(section, owner, note);

                PenController.onReceiveOfflineDataList(new OfflineDataListReceivedEventArgs(info));
            }
            break;

            case Cmd.OFFLINE_DATA_RESPONSE:
            {
                mTotalOfflineStroke    = packet.GetInt();
                mReceivedOfflineStroke = 0;
                mTotalOfflineDataSize  = packet.GetInt();

                bool isCompressed = packet.GetByte() == 1;

                PenController.onStartOfflineDownload();
            }
            break;

            case Cmd.OFFLINE_PACKET_REQUEST:
            {
                #region offline data parsing

                List <Stroke> result = new List <Stroke>();

                short packetId = packet.GetShort();

                bool isCompressed = packet.GetByte() == 1;

                short sizeBefore = packet.GetShort();

                short sizeAfter = packet.GetShort();

                short location = (short)(packet.GetByte() & 0xFF);

                byte[] rb = packet.GetBytes(4);

                int section = (int)(rb[3] & 0xFF);

                int owner = ByteConverter.ByteToInt(new byte[] { rb[0], rb[1], rb[2], (byte)0x00 });

                int note = packet.GetInt();

                short strCount = packet.GetShort();

                mReceivedOfflineStroke += strCount;

                Debug.WriteLine(" packetId : {0}, isCompressed : {1}, sizeBefore : {2}, sizeAfter : {3}, size : {4}", packetId, isCompressed, sizeBefore, sizeAfter, packet.Data.Length - 18);

                if (sizeAfter != (packet.Data.Length - 18))
                {
                    SendOfflinePacketResponse(packetId, false);
                    return;
                }

                byte[] oData = packet.GetBytes(sizeAfter);

                GZipStream gzipStream = new GZipStream(new System.IO.MemoryStream(oData), CompressionLevel.Fastest);

                byte[] strData = Ionic.Zlib.ZlibStream.UncompressBuffer(oData);

                if (strData.Length != sizeBefore)
                {
                    SendOfflinePacketResponse(packetId, false);
                    return;
                }

                ByteUtil butil = new ByteUtil(strData);

                for (int i = 0; i < strCount; i++)
                {
                    int pageId = butil.GetInt();

                    long timeStart = butil.GetLong();

                    long timeEnd = butil.GetLong();

                    int penTipType = (int)(butil.GetByte() & 0xFF);

                    int color = butil.GetInt();

                    short dotCount = butil.GetShort();

                    long time = timeStart;

                    //System.Console.WriteLine( "pageId : {0}, timeStart : {1}, timeEnd : {2}, penTipType : {3}, color : {4}, dotCount : {5}, time : {6},", pageId, timeStart, timeEnd, penTipType, color, dotCount, time );

                    Stroke stroke = new Stroke(section, owner, note, pageId);

                    for (int j = 0; j < dotCount; j++)
                    {
                        byte dotChecksum = butil.GetChecksum(15);

                        int timeadd = butil.GetByte();

                        time += timeadd;

                        int force = butil.GetShort();

                        int x = butil.GetShort();
                        int y = butil.GetShort();

                        int fx = butil.GetByte();
                        int fy = butil.GetByte();

                        int tx = butil.GetByte();
                        int ty = butil.GetByte();

                        int twist = butil.GetShort();

                        short reserved = butil.GetShort();

                        byte checksum = butil.GetByte();

                        //System.Console.WriteLine( "x : {0}, y : {1}, force : {2}, checksum : {3}, dotChecksum : {4}", tx, ty, twist, checksum, dotChecksum );

                        if (dotChecksum != checksum)
                        {
                            SendOfflinePacketResponse(packetId, false);
                            result.Clear();
                            return;
                        }

                        DotTypes dotType;

                        if (j == 0)
                        {
                            dotType = DotTypes.PEN_DOWN;
                        }
                        else if (j == dotCount - 1)
                        {
                            dotType = DotTypes.PEN_UP;
                        }
                        else
                        {
                            dotType = DotTypes.PEN_MOVE;
                        }

                        stroke.Add(MakeDot(PenMaxForce, owner, section, note, pageId, time, x, y, fx, fy, force, dotType, color));
                    }

                    result.Add(stroke);
                }

                SendOfflinePacketResponse(packetId);

                PenController.onReceiveOfflineStrokes(new OfflineStrokeReceivedEventArgs(mTotalOfflineStroke, mReceivedOfflineStroke, result.ToArray()));

                if (location == 2)
                {
                    PenController.onFinishedOfflineDownload(new SimpleResultEventArgs(true));
                }

                #endregion
            }
            break;

            case Cmd.OFFLINE_DATA_DELETE_RESPONSE:
            {
                PenController.onRemovedOfflineData(new SimpleResultEventArgs(packet.Result == 0x00));
            }
            break;
                #endregion

                #region firmware response
            case Cmd.FIRMWARE_UPLOAD_RESPONSE:
            {
                if (packet.Result != 0 || packet.GetByteToInt() != 0)
                {
                    IsUploading = false;
                    PenController.onReceiveFirmwareUpdateResult(new SimpleResultEventArgs(false));
                }
            }
            break;

            case Cmd.FIRMWARE_PACKET_REQUEST:
            {
                int status = packet.GetByteToInt();
                int offset = packet.GetInt();

                ResponseChunkRequest(offset, status != 3);
            }
            break;
                #endregion

            case Cmd.ONLINE_DATA_RESPONSE:
                break;



            default:
                break;
            }
        }