add Camera Task Sdk and Arg def

liuxiaolong

2019-05-21 886bb215241a3ed451de072f2b2939eae2f49f78

add Camera Task Sdk and Arg def

 protomsg.pb.go

@@ -1,12 +1,11 @@
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: protomsg.proto

package protomsg

import (
    fmt "fmt"
    proto "github.com/gogo/protobuf/proto"
    io "io"
    proto "github.com/golang/protobuf/proto"
    math "math"
)

@@ -19,12 +18,15 @@
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

type TaskLabel struct {
    Taskid string   `protobuf:"bytes,1,opt,name=taskid,proto3" json:"taskid,omitempty"`
    Sdkids []string `protobuf:"bytes,2,rep,name=sdkids,proto3" json:"sdkids,omitempty"`
    Index  int32    `protobuf:"varint,3,opt,name=index,proto3" json:"index,omitempty"`
    Taskid               string   `protobuf:"bytes,1,opt,name=taskid,proto3" json:"taskid,omitempty"`
    Sdkids               []string `protobuf:"bytes,2,rep,name=sdkids,proto3" json:"sdkids,omitempty"`
    Index                int32    `protobuf:"varint,3,opt,name=index,proto3" json:"index,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

func (m *TaskLabel) Reset()         { *m = TaskLabel{} }
@@ -33,26 +35,18 @@
func (*TaskLabel) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{0}
}

func (m *TaskLabel) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
    return xxx_messageInfo_TaskLabel.Unmarshal(m, b)
}
func (m *TaskLabel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    if deterministic {
        return xxx_messageInfo_TaskLabel.Marshal(b, m, deterministic)
    } else {
        b = b[:cap(b)]
        n, err := m.MarshalTo(b)
        if err != nil {
            return nil, err
        }
        return b[:n], nil
    }
    return xxx_messageInfo_TaskLabel.Marshal(b, m, deterministic)
}
func (m *TaskLabel) XXX_Merge(src proto.Message) {
    xxx_messageInfo_TaskLabel.Merge(m, src)
}
func (m *TaskLabel) XXX_Size() int {
    return m.Size()
    return xxx_messageInfo_TaskLabel.Size(m)
}
func (m *TaskLabel) XXX_DiscardUnknown() {
    xxx_messageInfo_TaskLabel.DiscardUnknown(m)
@@ -82,9 +76,12 @@
}

type SdkMessage struct {
    Cid     string     `protobuf:"bytes,1,opt,name=cid,proto3" json:"cid,omitempty"`
    Tasklab *TaskLabel `protobuf:"bytes,2,opt,name=tasklab,proto3" json:"tasklab,omitempty"`
    Data    []byte     `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
    Cid                  string     `protobuf:"bytes,1,opt,name=cid,proto3" json:"cid,omitempty"`
    Tasklab              *TaskLabel `protobuf:"bytes,2,opt,name=tasklab,proto3" json:"tasklab,omitempty"`
    Data                 []byte     `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
    XXX_NoUnkeyedLiteral struct{}   `json:"-"`
    XXX_unrecognized     []byte     `json:"-"`
    XXX_sizecache        int32      `json:"-"`
}

func (m *SdkMessage) Reset()         { *m = SdkMessage{} }
@@ -93,26 +90,18 @@
func (*SdkMessage) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{1}
}

func (m *SdkMessage) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
    return xxx_messageInfo_SdkMessage.Unmarshal(m, b)
}
func (m *SdkMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    if deterministic {
        return xxx_messageInfo_SdkMessage.Marshal(b, m, deterministic)
    } else {
        b = b[:cap(b)]
        n, err := m.MarshalTo(b)
        if err != nil {
            return nil, err
        }
        return b[:n], nil
    }
    return xxx_messageInfo_SdkMessage.Marshal(b, m, deterministic)
}
func (m *SdkMessage) XXX_Merge(src proto.Message) {
    xxx_messageInfo_SdkMessage.Merge(m, src)
}
func (m *SdkMessage) XXX_Size() int {
    return m.Size()
    return xxx_messageInfo_SdkMessage.Size(m)
}
func (m *SdkMessage) XXX_DiscardUnknown() {
    xxx_messageInfo_SdkMessage.DiscardUnknown(m)
@@ -143,9 +132,12 @@

// Image ipc struct
type Image struct {
    Width  int32  `protobuf:"varint,1,opt,name=width,proto3" json:"width,omitempty"`
    Height int32  `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
    Data   []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
    Width                int32    `protobuf:"varint,1,opt,name=width,proto3" json:"width,omitempty"`
    Height               int32    `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
    Data                 []byte   `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

func (m *Image) Reset()         { *m = Image{} }
@@ -154,26 +146,18 @@
func (*Image) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{2}
}

func (m *Image) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
    return xxx_messageInfo_Image.Unmarshal(m, b)
}
func (m *Image) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    if deterministic {
        return xxx_messageInfo_Image.Marshal(b, m, deterministic)
    } else {
        b = b[:cap(b)]
        n, err := m.MarshalTo(b)
        if err != nil {
            return nil, err
        }
        return b[:n], nil
    }
    return xxx_messageInfo_Image.Marshal(b, m, deterministic)
}
func (m *Image) XXX_Merge(src proto.Message) {
    xxx_messageInfo_Image.Merge(m, src)
}
func (m *Image) XXX_Size() int {
    return m.Size()
    return xxx_messageInfo_Image.Size(m)
}
func (m *Image) XXX_DiscardUnknown() {
    xxx_messageInfo_Image.DiscardUnknown(m)
@@ -202,758 +186,1034 @@
    return nil
}

//Area结构体
type Area struct {
    Id                   int32    `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
    Parentid             int32    `protobuf:"varint,2,opt,name=parentid,proto3" json:"parentid,omitempty"`
    Name                 string   `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

func (m *Area) Reset()         { *m = Area{} }
func (m *Area) String() string { return proto.CompactTextString(m) }
func (*Area) ProtoMessage()    {}
func (*Area) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{3}
}

func (m *Area) XXX_Unmarshal(b []byte) error {
    return xxx_messageInfo_Area.Unmarshal(m, b)
}
func (m *Area) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    return xxx_messageInfo_Area.Marshal(b, m, deterministic)
}
func (m *Area) XXX_Merge(src proto.Message) {
    xxx_messageInfo_Area.Merge(m, src)
}
func (m *Area) XXX_Size() int {
    return xxx_messageInfo_Area.Size(m)
}
func (m *Area) XXX_DiscardUnknown() {
    xxx_messageInfo_Area.DiscardUnknown(m)
}

var xxx_messageInfo_Area proto.InternalMessageInfo

func (m *Area) GetId() int32 {
    if m != nil {
        return m.Id
    }
    return 0
}

func (m *Area) GetParentid() int32 {
    if m != nil {
        return m.Parentid
    }
    return 0
}

func (m *Area) GetName() string {
    if m != nil {
        return m.Name
    }
    return ""
}

//Camera结构体
type Camera struct {
    Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
    Name                 string   `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
    Type                 int32    `protobuf:"varint,3,opt,name=type,proto3" json:"type,omitempty"`
    Addr                 string   `protobuf:"bytes,4,opt,name=addr,proto3" json:"addr,omitempty"`
    Areaid               int32    `protobuf:"varint,5,opt,name=areaid,proto3" json:"areaid,omitempty"`
    Longitude            float32  `protobuf:"fixed32,6,opt,name=longitude,proto3" json:"longitude,omitempty"`
    Latitude             float32  `protobuf:"fixed32,7,opt,name=latitude,proto3" json:"latitude,omitempty"`
    Rtsp                 string   `protobuf:"bytes,8,opt,name=rtsp,proto3" json:"rtsp,omitempty"`
    Ip                   string   `protobuf:"bytes,9,opt,name=ip,proto3" json:"ip,omitempty"`
    Port                 int32    `protobuf:"varint,10,opt,name=port,proto3" json:"port,omitempty"`
    Username             string   `protobuf:"bytes,11,opt,name=username,proto3" json:"username,omitempty"`
    Password             string   `protobuf:"bytes,12,opt,name=password,proto3" json:"password,omitempty"`
    Brand                string   `protobuf:"bytes,13,opt,name=brand,proto3" json:"brand,omitempty"`
    Reserved             string   `protobuf:"bytes,14,opt,name=reserved,proto3" json:"reserved,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

func (m *Camera) Reset()         { *m = Camera{} }
func (m *Camera) String() string { return proto.CompactTextString(m) }
func (*Camera) ProtoMessage()    {}
func (*Camera) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{4}
}

func (m *Camera) XXX_Unmarshal(b []byte) error {
    return xxx_messageInfo_Camera.Unmarshal(m, b)
}
func (m *Camera) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    return xxx_messageInfo_Camera.Marshal(b, m, deterministic)
}
func (m *Camera) XXX_Merge(src proto.Message) {
    xxx_messageInfo_Camera.Merge(m, src)
}
func (m *Camera) XXX_Size() int {
    return xxx_messageInfo_Camera.Size(m)
}
func (m *Camera) XXX_DiscardUnknown() {
    xxx_messageInfo_Camera.DiscardUnknown(m)
}

var xxx_messageInfo_Camera proto.InternalMessageInfo

func (m *Camera) GetId() string {
    if m != nil {
        return m.Id
    }
    return ""
}

func (m *Camera) GetName() string {
    if m != nil {
        return m.Name
    }
    return ""
}

func (m *Camera) GetType() int32 {
    if m != nil {
        return m.Type
    }
    return 0
}

func (m *Camera) GetAddr() string {
    if m != nil {
        return m.Addr
    }
    return ""
}

func (m *Camera) GetAreaid() int32 {
    if m != nil {
        return m.Areaid
    }
    return 0
}

func (m *Camera) GetLongitude() float32 {
    if m != nil {
        return m.Longitude
    }
    return 0
}

func (m *Camera) GetLatitude() float32 {
    if m != nil {
        return m.Latitude
    }
    return 0
}

func (m *Camera) GetRtsp() string {
    if m != nil {
        return m.Rtsp
    }
    return ""
}

func (m *Camera) GetIp() string {
    if m != nil {
        return m.Ip
    }
    return ""
}

func (m *Camera) GetPort() int32 {
    if m != nil {
        return m.Port
    }
    return 0
}

func (m *Camera) GetUsername() string {
    if m != nil {
        return m.Username
    }
    return ""
}

func (m *Camera) GetPassword() string {
    if m != nil {
        return m.Password
    }
    return ""
}

func (m *Camera) GetBrand() string {
    if m != nil {
        return m.Brand
    }
    return ""
}

func (m *Camera) GetReserved() string {
    if m != nil {
        return m.Reserved
    }
    return ""
}

//Task结构体
type Task struct {
    Taskid               string   `protobuf:"bytes,1,opt,name=taskid,proto3" json:"taskid,omitempty"`
    Taskname             string   `protobuf:"bytes,2,opt,name=taskname,proto3" json:"taskname,omitempty"`
    CreateAt             string   `protobuf:"bytes,3,opt,name=create_at,json=createAt,proto3" json:"create_at,omitempty"`
    CreateBy             string   `protobuf:"bytes,4,opt,name=create_by,json=createBy,proto3" json:"create_by,omitempty"`
    UpdateAt             string   `protobuf:"bytes,5,opt,name=update_at,json=updateAt,proto3" json:"update_at,omitempty"`
    Enable               bool     `protobuf:"varint,6,opt,name=enable,proto3" json:"enable,omitempty"`
    IsAlarm              bool     `protobuf:"varint,7,opt,name=is_alarm,json=isAlarm,proto3" json:"is_alarm,omitempty"`
    DelFlag              bool     `protobuf:"varint,8,opt,name=del_flag,json=delFlag,proto3" json:"del_flag,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

func (m *Task) Reset()         { *m = Task{} }
func (m *Task) String() string { return proto.CompactTextString(m) }
func (*Task) ProtoMessage()    {}
func (*Task) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{5}
}

func (m *Task) XXX_Unmarshal(b []byte) error {
    return xxx_messageInfo_Task.Unmarshal(m, b)
}
func (m *Task) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    return xxx_messageInfo_Task.Marshal(b, m, deterministic)
}
func (m *Task) XXX_Merge(src proto.Message) {
    xxx_messageInfo_Task.Merge(m, src)
}
func (m *Task) XXX_Size() int {
    return xxx_messageInfo_Task.Size(m)
}
func (m *Task) XXX_DiscardUnknown() {
    xxx_messageInfo_Task.DiscardUnknown(m)
}

var xxx_messageInfo_Task proto.InternalMessageInfo

func (m *Task) GetTaskid() string {
    if m != nil {
        return m.Taskid
    }
    return ""
}

func (m *Task) GetTaskname() string {
    if m != nil {
        return m.Taskname
    }
    return ""
}

func (m *Task) GetCreateAt() string {
    if m != nil {
        return m.CreateAt
    }
    return ""
}

func (m *Task) GetCreateBy() string {
    if m != nil {
        return m.CreateBy
    }
    return ""
}

func (m *Task) GetUpdateAt() string {
    if m != nil {
        return m.UpdateAt
    }
    return ""
}

func (m *Task) GetEnable() bool {
    if m != nil {
        return m.Enable
    }
    return false
}

func (m *Task) GetIsAlarm() bool {
    if m != nil {
        return m.IsAlarm
    }
    return false
}

func (m *Task) GetDelFlag() bool {
    if m != nil {
        return m.DelFlag
    }
    return false
}

//摄像机任务
type CameraTask struct {
    Id                   string    `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
    CameraIds            string    `protobuf:"bytes,2,opt,name=camera_ids,json=cameraIds,proto3" json:"camera_ids,omitempty"`
    TaskId               string    `protobuf:"bytes,3,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"`
    TimeRule             []*DayCtl `protobuf:"bytes,4,rep,name=time_rule,json=timeRule,proto3" json:"time_rule,omitempty"`
    ReactRule            string    `protobuf:"bytes,5,opt,name=react_rule,json=reactRule,proto3" json:"react_rule,omitempty"`
    ReactDevice          string    `protobuf:"bytes,6,opt,name=react_device,json=reactDevice,proto3" json:"react_device,omitempty"`
    DelFlag              bool      `protobuf:"varint,7,opt,name=del_flag,json=delFlag,proto3" json:"del_flag,omitempty"`
    UpdateFlag           bool      `protobuf:"varint,8,opt,name=update_flag,json=updateFlag,proto3" json:"update_flag,omitempty"`
    Enable               bool      `protobuf:"varint,9,opt,name=enable,proto3" json:"enable,omitempty"`
    Sort                 int32     `protobuf:"varint,10,opt,name=sort,proto3" json:"sort,omitempty"`
    IsFull               bool      `protobuf:"varint,11,opt,name=is_full,json=isFull,proto3" json:"is_full,omitempty"`
    LinkGroupId          string    `protobuf:"bytes,12,opt,name=link_group_id,json=linkGroupId,proto3" json:"link_group_id,omitempty"`
    XXX_NoUnkeyedLiteral struct{}  `json:"-"`
    XXX_unrecognized     []byte    `json:"-"`
    XXX_sizecache        int32     `json:"-"`
}

func (m *CameraTask) Reset()         { *m = CameraTask{} }
func (m *CameraTask) String() string { return proto.CompactTextString(m) }
func (*CameraTask) ProtoMessage()    {}
func (*CameraTask) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{6}
}

func (m *CameraTask) XXX_Unmarshal(b []byte) error {
    return xxx_messageInfo_CameraTask.Unmarshal(m, b)
}
func (m *CameraTask) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    return xxx_messageInfo_CameraTask.Marshal(b, m, deterministic)
}
func (m *CameraTask) XXX_Merge(src proto.Message) {
    xxx_messageInfo_CameraTask.Merge(m, src)
}
func (m *CameraTask) XXX_Size() int {
    return xxx_messageInfo_CameraTask.Size(m)
}
func (m *CameraTask) XXX_DiscardUnknown() {
    xxx_messageInfo_CameraTask.DiscardUnknown(m)
}

var xxx_messageInfo_CameraTask proto.InternalMessageInfo

func (m *CameraTask) GetId() string {
    if m != nil {
        return m.Id
    }
    return ""
}

func (m *CameraTask) GetCameraIds() string {
    if m != nil {
        return m.CameraIds
    }
    return ""
}

func (m *CameraTask) GetTaskId() string {
    if m != nil {
        return m.TaskId
    }
    return ""
}

func (m *CameraTask) GetTimeRule() []*DayCtl {
    if m != nil {
        return m.TimeRule
    }
    return nil
}

func (m *CameraTask) GetReactRule() string {
    if m != nil {
        return m.ReactRule
    }
    return ""
}

func (m *CameraTask) GetReactDevice() string {
    if m != nil {
        return m.ReactDevice
    }
    return ""
}

func (m *CameraTask) GetDelFlag() bool {
    if m != nil {
        return m.DelFlag
    }
    return false
}

func (m *CameraTask) GetUpdateFlag() bool {
    if m != nil {
        return m.UpdateFlag
    }
    return false
}

func (m *CameraTask) GetEnable() bool {
    if m != nil {
        return m.Enable
    }
    return false
}

func (m *CameraTask) GetSort() int32 {
    if m != nil {
        return m.Sort
    }
    return 0
}

func (m *CameraTask) GetIsFull() bool {
    if m != nil {
        return m.IsFull
    }
    return false
}

func (m *CameraTask) GetLinkGroupId() string {
    if m != nil {
        return m.LinkGroupId
    }
    return ""
}

//DayCtl struct   每天的时间控制规则
type DayCtl struct {
    Day                  int32        `protobuf:"varint,1,opt,name=day,proto3" json:"day,omitempty"`
    TimeRange            []*TimeRange `protobuf:"bytes,2,rep,name=time_range,json=timeRange,proto3" json:"time_range,omitempty"`
    XXX_NoUnkeyedLiteral struct{}     `json:"-"`
    XXX_unrecognized     []byte       `json:"-"`
    XXX_sizecache        int32        `json:"-"`
}

func (m *DayCtl) Reset()         { *m = DayCtl{} }
func (m *DayCtl) String() string { return proto.CompactTextString(m) }
func (*DayCtl) ProtoMessage()    {}
func (*DayCtl) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{7}
}

func (m *DayCtl) XXX_Unmarshal(b []byte) error {
    return xxx_messageInfo_DayCtl.Unmarshal(m, b)
}
func (m *DayCtl) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    return xxx_messageInfo_DayCtl.Marshal(b, m, deterministic)
}
func (m *DayCtl) XXX_Merge(src proto.Message) {
    xxx_messageInfo_DayCtl.Merge(m, src)
}
func (m *DayCtl) XXX_Size() int {
    return xxx_messageInfo_DayCtl.Size(m)
}
func (m *DayCtl) XXX_DiscardUnknown() {
    xxx_messageInfo_DayCtl.DiscardUnknown(m)
}

var xxx_messageInfo_DayCtl proto.InternalMessageInfo

func (m *DayCtl) GetDay() int32 {
    if m != nil {
        return m.Day
    }
    return 0
}

func (m *DayCtl) GetTimeRange() []*TimeRange {
    if m != nil {
        return m.TimeRange
    }
    return nil
}

//时间起始范围
type TimeRange struct {
    Start                string   `protobuf:"bytes,1,opt,name=start,proto3" json:"start,omitempty"`
    End                  string   `protobuf:"bytes,2,opt,name=end,proto3" json:"end,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

func (m *TimeRange) Reset()         { *m = TimeRange{} }
func (m *TimeRange) String() string { return proto.CompactTextString(m) }
func (*TimeRange) ProtoMessage()    {}
func (*TimeRange) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{8}
}

func (m *TimeRange) XXX_Unmarshal(b []byte) error {
    return xxx_messageInfo_TimeRange.Unmarshal(m, b)
}
func (m *TimeRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    return xxx_messageInfo_TimeRange.Marshal(b, m, deterministic)
}
func (m *TimeRange) XXX_Merge(src proto.Message) {
    xxx_messageInfo_TimeRange.Merge(m, src)
}
func (m *TimeRange) XXX_Size() int {
    return xxx_messageInfo_TimeRange.Size(m)
}
func (m *TimeRange) XXX_DiscardUnknown() {
    xxx_messageInfo_TimeRange.DiscardUnknown(m)
}

var xxx_messageInfo_TimeRange proto.InternalMessageInfo

func (m *TimeRange) GetStart() string {
    if m != nil {
        return m.Start
    }
    return ""
}

func (m *TimeRange) GetEnd() string {
    if m != nil {
        return m.End
    }
    return ""
}

//Polygon struct
type Polygon struct {
    Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
    Name                 string   `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
    Points               []*Point `protobuf:"bytes,4,rep,name=points,proto3" json:"points,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

func (m *Polygon) Reset()         { *m = Polygon{} }
func (m *Polygon) String() string { return proto.CompactTextString(m) }
func (*Polygon) ProtoMessage()    {}
func (*Polygon) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{9}
}

func (m *Polygon) XXX_Unmarshal(b []byte) error {
    return xxx_messageInfo_Polygon.Unmarshal(m, b)
}
func (m *Polygon) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    return xxx_messageInfo_Polygon.Marshal(b, m, deterministic)
}
func (m *Polygon) XXX_Merge(src proto.Message) {
    xxx_messageInfo_Polygon.Merge(m, src)
}
func (m *Polygon) XXX_Size() int {
    return xxx_messageInfo_Polygon.Size(m)
}
func (m *Polygon) XXX_DiscardUnknown() {
    xxx_messageInfo_Polygon.DiscardUnknown(m)
}

var xxx_messageInfo_Polygon proto.InternalMessageInfo

func (m *Polygon) GetId() string {
    if m != nil {
        return m.Id
    }
    return ""
}

func (m *Polygon) GetName() string {
    if m != nil {
        return m.Name
    }
    return ""
}

func (m *Polygon) GetPoints() []*Point {
    if m != nil {
        return m.Points
    }
    return nil
}

//Point struct
type Point struct {
    X                    string   `protobuf:"bytes,1,opt,name=x,proto3" json:"x,omitempty"`
    Y                    string   `protobuf:"bytes,2,opt,name=y,proto3" json:"y,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

func (m *Point) Reset()         { *m = Point{} }
func (m *Point) String() string { return proto.CompactTextString(m) }
func (*Point) ProtoMessage()    {}
func (*Point) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{10}
}

func (m *Point) XXX_Unmarshal(b []byte) error {
    return xxx_messageInfo_Point.Unmarshal(m, b)
}
func (m *Point) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    return xxx_messageInfo_Point.Marshal(b, m, deterministic)
}
func (m *Point) XXX_Merge(src proto.Message) {
    xxx_messageInfo_Point.Merge(m, src)
}
func (m *Point) XXX_Size() int {
    return xxx_messageInfo_Point.Size(m)
}
func (m *Point) XXX_DiscardUnknown() {
    xxx_messageInfo_Point.DiscardUnknown(m)
}

var xxx_messageInfo_Point proto.InternalMessageInfo

func (m *Point) GetX() string {
    if m != nil {
        return m.X
    }
    return ""
}

func (m *Point) GetY() string {
    if m != nil {
        return m.Y
    }
    return ""
}

type CameraTaskArgs struct {
    Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
    CameraTaskId         string   `protobuf:"bytes,2,opt,name=camera_task_id,json=cameraTaskId,proto3" json:"camera_task_id,omitempty"`
    CameraId             string   `protobuf:"bytes,3,opt,name=camera_id,json=cameraId,proto3" json:"camera_id,omitempty"`
    PolygonId            string   `protobuf:"bytes,4,opt,name=polygon_id,json=polygonId,proto3" json:"polygon_id,omitempty"`
    SdkId                string   `protobuf:"bytes,5,opt,name=sdk_id,json=sdkId,proto3" json:"sdk_id,omitempty"`
    SdkArgAlias          string   `protobuf:"bytes,6,opt,name=sdk_arg_alias,json=sdkArgAlias,proto3" json:"sdk_arg_alias,omitempty"`
    Operator             string   `protobuf:"bytes,7,opt,name=operator,proto3" json:"operator,omitempty"`
    OperatorType         string   `protobuf:"bytes,8,opt,name=operator_type,json=operatorType,proto3" json:"operator_type,omitempty"`
    SdkArgValue          string   `protobuf:"bytes,9,opt,name=sdk_arg_value,json=sdkArgValue,proto3" json:"sdk_arg_value,omitempty"`
    Sort                 int32    `protobuf:"varint,10,opt,name=sort,proto3" json:"sort,omitempty"`
    RuleWithNext         string   `protobuf:"bytes,11,opt,name=rule_with_next,json=ruleWithNext,proto3" json:"rule_with_next,omitempty"`
    GroupId              string   `protobuf:"bytes,12,opt,name=group_id,json=groupId,proto3" json:"group_id,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

func (m *CameraTaskArgs) Reset()         { *m = CameraTaskArgs{} }
func (m *CameraTaskArgs) String() string { return proto.CompactTextString(m) }
func (*CameraTaskArgs) ProtoMessage()    {}
func (*CameraTaskArgs) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{11}
}

func (m *CameraTaskArgs) XXX_Unmarshal(b []byte) error {
    return xxx_messageInfo_CameraTaskArgs.Unmarshal(m, b)
}
func (m *CameraTaskArgs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    return xxx_messageInfo_CameraTaskArgs.Marshal(b, m, deterministic)
}
func (m *CameraTaskArgs) XXX_Merge(src proto.Message) {
    xxx_messageInfo_CameraTaskArgs.Merge(m, src)
}
func (m *CameraTaskArgs) XXX_Size() int {
    return xxx_messageInfo_CameraTaskArgs.Size(m)
}
func (m *CameraTaskArgs) XXX_DiscardUnknown() {
    xxx_messageInfo_CameraTaskArgs.DiscardUnknown(m)
}

var xxx_messageInfo_CameraTaskArgs proto.InternalMessageInfo

func (m *CameraTaskArgs) GetId() string {
    if m != nil {
        return m.Id
    }
    return ""
}

func (m *CameraTaskArgs) GetCameraTaskId() string {
    if m != nil {
        return m.CameraTaskId
    }
    return ""
}

func (m *CameraTaskArgs) GetCameraId() string {
    if m != nil {
        return m.CameraId
    }
    return ""
}

func (m *CameraTaskArgs) GetPolygonId() string {
    if m != nil {
        return m.PolygonId
    }
    return ""
}

func (m *CameraTaskArgs) GetSdkId() string {
    if m != nil {
        return m.SdkId
    }
    return ""
}

func (m *CameraTaskArgs) GetSdkArgAlias() string {
    if m != nil {
        return m.SdkArgAlias
    }
    return ""
}

func (m *CameraTaskArgs) GetOperator() string {
    if m != nil {
        return m.Operator
    }
    return ""
}

func (m *CameraTaskArgs) GetOperatorType() string {
    if m != nil {
        return m.OperatorType
    }
    return ""
}

func (m *CameraTaskArgs) GetSdkArgValue() string {
    if m != nil {
        return m.SdkArgValue
    }
    return ""
}

func (m *CameraTaskArgs) GetSort() int32 {
    if m != nil {
        return m.Sort
    }
    return 0
}

func (m *CameraTaskArgs) GetRuleWithNext() string {
    if m != nil {
        return m.RuleWithNext
    }
    return ""
}

func (m *CameraTaskArgs) GetGroupId() string {
    if m != nil {
        return m.GroupId
    }
    return ""
}

//Sdk struct
type Sdk struct {
    Id                   string    `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
    CreateTime           string    `protobuf:"bytes,2,opt,name=create_time,json=createTime,proto3" json:"create_time,omitempty"`
    UpdateTime           string    `protobuf:"bytes,3,opt,name=update_time,json=updateTime,proto3" json:"update_time,omitempty"`
    CreateBy             string    `protobuf:"bytes,4,opt,name=create_by,json=createBy,proto3" json:"create_by,omitempty"`
    DelFlag              string    `protobuf:"bytes,5,opt,name=del_flag,json=delFlag,proto3" json:"del_flag,omitempty"`
    Enabled              string    `protobuf:"bytes,6,opt,name=enabled,proto3" json:"enabled,omitempty"`
    SdkName              string    `protobuf:"bytes,7,opt,name=sdk_name,json=sdkName,proto3" json:"sdk_name,omitempty"`
    Icon                 string    `protobuf:"bytes,8,opt,name=icon,proto3" json:"icon,omitempty"`
    Url                  string    `protobuf:"bytes,9,opt,name=url,proto3" json:"url,omitempty"`
    Args                 []*SdkArg `protobuf:"bytes,10,rep,name=args,proto3" json:"args,omitempty"`
    XXX_NoUnkeyedLiteral struct{}  `json:"-"`
    XXX_unrecognized     []byte    `json:"-"`
    XXX_sizecache        int32     `json:"-"`
}

func (m *Sdk) Reset()         { *m = Sdk{} }
func (m *Sdk) String() string { return proto.CompactTextString(m) }
func (*Sdk) ProtoMessage()    {}
func (*Sdk) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{12}
}

func (m *Sdk) XXX_Unmarshal(b []byte) error {
    return xxx_messageInfo_Sdk.Unmarshal(m, b)
}
func (m *Sdk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    return xxx_messageInfo_Sdk.Marshal(b, m, deterministic)
}
func (m *Sdk) XXX_Merge(src proto.Message) {
    xxx_messageInfo_Sdk.Merge(m, src)
}
func (m *Sdk) XXX_Size() int {
    return xxx_messageInfo_Sdk.Size(m)
}
func (m *Sdk) XXX_DiscardUnknown() {
    xxx_messageInfo_Sdk.DiscardUnknown(m)
}

var xxx_messageInfo_Sdk proto.InternalMessageInfo

func (m *Sdk) GetId() string {
    if m != nil {
        return m.Id
    }
    return ""
}

func (m *Sdk) GetCreateTime() string {
    if m != nil {
        return m.CreateTime
    }
    return ""
}

func (m *Sdk) GetUpdateTime() string {
    if m != nil {
        return m.UpdateTime
    }
    return ""
}

func (m *Sdk) GetCreateBy() string {
    if m != nil {
        return m.CreateBy
    }
    return ""
}

func (m *Sdk) GetDelFlag() string {
    if m != nil {
        return m.DelFlag
    }
    return ""
}

func (m *Sdk) GetEnabled() string {
    if m != nil {
        return m.Enabled
    }
    return ""
}

func (m *Sdk) GetSdkName() string {
    if m != nil {
        return m.SdkName
    }
    return ""
}

func (m *Sdk) GetIcon() string {
    if m != nil {
        return m.Icon
    }
    return ""
}

func (m *Sdk) GetUrl() string {
    if m != nil {
        return m.Url
    }
    return ""
}

func (m *Sdk) GetArgs() []*SdkArg {
    if m != nil {
        return m.Args
    }
    return nil
}

//SdkArg struct
type SdkArg struct {
    Alias                string   `protobuf:"bytes,2,opt,name=alias,proto3" json:"alias,omitempty"`
    Name                 string   `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
    Type                 string   `protobuf:"bytes,4,opt,name=type,proto3" json:"type,omitempty"`
    Must                 bool     `protobuf:"varint,5,opt,name=must,proto3" json:"must,omitempty"`
    Range                string   `protobuf:"bytes,6,opt,name=range,proto3" json:"range,omitempty"`
    Sort                 int32    `protobuf:"varint,7,opt,name=sort,proto3" json:"sort,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

func (m *SdkArg) Reset()         { *m = SdkArg{} }
func (m *SdkArg) String() string { return proto.CompactTextString(m) }
func (*SdkArg) ProtoMessage()    {}
func (*SdkArg) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{13}
}

func (m *SdkArg) XXX_Unmarshal(b []byte) error {
    return xxx_messageInfo_SdkArg.Unmarshal(m, b)
}
func (m *SdkArg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    return xxx_messageInfo_SdkArg.Marshal(b, m, deterministic)
}
func (m *SdkArg) XXX_Merge(src proto.Message) {
    xxx_messageInfo_SdkArg.Merge(m, src)
}
func (m *SdkArg) XXX_Size() int {
    return xxx_messageInfo_SdkArg.Size(m)
}
func (m *SdkArg) XXX_DiscardUnknown() {
    xxx_messageInfo_SdkArg.DiscardUnknown(m)
}

var xxx_messageInfo_SdkArg proto.InternalMessageInfo

func (m *SdkArg) GetAlias() string {
    if m != nil {
        return m.Alias
    }
    return ""
}

func (m *SdkArg) GetName() string {
    if m != nil {
        return m.Name
    }
    return ""
}

func (m *SdkArg) GetType() string {
    if m != nil {
        return m.Type
    }
    return ""
}

func (m *SdkArg) GetMust() bool {
    if m != nil {
        return m.Must
    }
    return false
}

func (m *SdkArg) GetRange() string {
    if m != nil {
        return m.Range
    }
    return ""
}

func (m *SdkArg) GetSort() int32 {
    if m != nil {
        return m.Sort
    }
    return 0
}

func init() {
    proto.RegisterType((*TaskLabel)(nil), "protomsg.TaskLabel")
    proto.RegisterType((*SdkMessage)(nil), "protomsg.SdkMessage")
    proto.RegisterType((*Image)(nil), "protomsg.Image")
    proto.RegisterType((*Area)(nil), "protomsg.Area")
    proto.RegisterType((*Camera)(nil), "protomsg.Camera")
    proto.RegisterType((*Task)(nil), "protomsg.Task")
    proto.RegisterType((*CameraTask)(nil), "protomsg.CameraTask")
    proto.RegisterType((*DayCtl)(nil), "protomsg.DayCtl")
    proto.RegisterType((*TimeRange)(nil), "protomsg.TimeRange")
    proto.RegisterType((*Polygon)(nil), "protomsg.Polygon")
    proto.RegisterType((*Point)(nil), "protomsg.Point")
    proto.RegisterType((*CameraTaskArgs)(nil), "protomsg.CameraTaskArgs")
    proto.RegisterType((*Sdk)(nil), "protomsg.Sdk")
    proto.RegisterType((*SdkArg)(nil), "protomsg.SdkArg")
}

func init() { proto.RegisterFile("protomsg.proto", fileDescriptor_32de24555f916688) }

var fileDescriptor_32de24555f916688 = []byte{
    // 238 bytes of a gzipped FileDescriptorProto
    0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x8e, 0xbd, 0x4e, 0xc3, 0x30,
    0x14, 0x85, 0xe3, 0x06, 0x17, 0x7a, 0x41, 0x08, 0x99, 0x0a, 0x79, 0xb2, 0xac, 0x4c, 0x59, 0xe8,
    0x00, 0x6f, 0xc0, 0x56, 0x09, 0x06, 0x0c, 0x2f, 0x70, 0x83, 0xad, 0xc4, 0x72, 0x4b, 0x11, 0xb6,
    0x04, 0x8f, 0xc1, 0x63, 0x31, 0x66, 0x64, 0x44, 0xc9, 0x8b, 0x20, 0x3b, 0x3f, 0x13, 0xdb, 0xf9,
    0xae, 0xae, 0xbe, 0x73, 0xe0, 0xfc, 0xed, 0xfd, 0x10, 0x0e, 0x7b, 0x5f, 0x6f, 0x52, 0x60, 0x27,
    0x13, 0x17, 0x8f, 0xb0, 0x7a, 0x46, 0xef, 0xee, 0xb1, 0x32, 0x3b, 0x76, 0x05, 0xcb, 0x80, 0xde,
    0x59, 0xcd, 0x89, 0x24, 0xe5, 0x4a, 0x8d, 0x14, 0xef, 0x5e, 0x3b, 0xab, 0x3d, 0x5f, 0xc8, 0x3c,
    0xde, 0x07, 0x62, 0x6b, 0xa0, 0xf6, 0x55, 0x9b, 0x4f, 0x9e, 0x4b, 0x52, 0x52, 0x35, 0x40, 0x81,
    0x00, 0x4f, 0xda, 0x3d, 0x18, 0xef, 0xb1, 0x36, 0xec, 0x02, 0xf2, 0x97, 0x59, 0x18, 0x23, 0xbb,
    0x86, 0xe3, 0xe8, 0xdd, 0x61, 0xc5, 0x17, 0x92, 0x94, 0xa7, 0x37, 0x97, 0x9b, 0x79, 0xde, 0xbc,
    0x45, 0x4d, 0x3f, 0x8c, 0xc1, 0x91, 0xc6, 0x80, 0xa9, 0xe3, 0x4c, 0xa5, 0x5c, 0x6c, 0x81, 0x6e,
    0xf7, 0xd1, 0xbe, 0x06, 0xfa, 0x61, 0x75, 0x68, 0x92, 0x9f, 0xaa, 0x01, 0xe2, 0xde, 0xc6, 0xd8,
    0xba, 0x09, 0xa9, 0x80, 0xaa, 0x91, 0xfe, 0x53, 0xdd, 0xf1, 0xef, 0x4e, 0x90, 0xb6, 0x13, 0xe4,
    0xb7, 0x13, 0xe4, 0xab, 0x17, 0x59, 0xdb, 0x8b, 0xec, 0xa7, 0x17, 0x59, 0xb5, 0x4c, 0xab, 0x6e,
    0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x88, 0x81, 0x6c, 0xa1, 0x3d, 0x01, 0x00, 0x00,
    // 1044 bytes of a gzipped FileDescriptorProto
    0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x55, 0xcd, 0x8e, 0x23, 0x35,
    0x10, 0x56, 0x32, 0xf9, 0xe9, 0xae, 0x64, 0xc2, 0xaa, 0x59, 0xa0, 0x59, 0x40, 0x1b, 0x7a, 0x47,
    0x62, 0x2e, 0xec, 0x61, 0xf6, 0x09, 0xc2, 0xae, 0x06, 0x45, 0x82, 0xd1, 0xe2, 0x59, 0x2d, 0xc7,
    0x96, 0x13, 0x7b, 0x7b, 0xac, 0x38, 0xdd, 0x2d, 0xdb, 0x3d, 0x93, 0xdc, 0x79, 0x00, 0x1e, 0x8b,
    0xb7, 0xe0, 0xce, 0x0b, 0x70, 0x45, 0xe5, 0x72, 0x77, 0x32, 0xb3, 0x03, 0xe2, 0x56, 0xf5, 0x55,
    0xb9, 0x5c, 0xf5, 0xb9, 0xaa, 0x0c, 0xb3, 0xda, 0x54, 0xae, 0xda, 0xda, 0xe2, 0xa5, 0x17, 0x92,
    0xa8, 0xd5, 0xb3, 0x5f, 0x20, 0x7e, 0xc7, 0xed, 0xe6, 0x27, 0xbe, 0x92, 0x3a, 0xf9, 0x1c, 0x46,
    0x8e, 0xdb, 0x8d, 0x12, 0x69, 0x6f, 0xde, 0x3b, 0x8f, 0x59, 0xd0, 0x10, 0xb7, 0x62, 0xa3, 0x84,
    0x4d, 0xfb, 0xf3, 0x13, 0xc4, 0x49, 0x4b, 0x9e, 0xc2, 0x50, 0x95, 0x42, 0xee, 0xd2, 0x93, 0x79,
    0xef, 0x7c, 0xc8, 0x48, 0xc9, 0x38, 0xc0, 0xb5, 0xd8, 0xfc, 0x2c, 0xad, 0xe5, 0x85, 0x4c, 0x9e,
    0xc0, 0xc9, 0xba, 0x0b, 0x88, 0x62, 0xf2, 0x3d, 0x8c, 0x31, 0xae, 0xe6, 0xab, 0xb4, 0x3f, 0xef,
    0x9d, 0x4f, 0x2e, 0x3e, 0x7d, 0xd9, 0xa5, 0xd7, 0xe5, 0xc2, 0x5a, 0x9f, 0x24, 0x81, 0x81, 0xe0,
    0x8e, 0xfb, 0x3b, 0xa6, 0xcc, 0xcb, 0xd9, 0x12, 0x86, 0xcb, 0x2d, 0x46, 0x7f, 0x0a, 0xc3, 0x3b,
    0x25, 0xdc, 0x8d, 0x8f, 0x3f, 0x64, 0xa4, 0x60, 0xbe, 0x37, 0x52, 0x15, 0x37, 0xce, 0x5f, 0x30,
    0x64, 0x41, 0x7b, 0x34, 0xd4, 0x25, 0x0c, 0x16, 0x46, 0xf2, 0x64, 0x06, 0xfd, 0x90, 0xe6, 0x90,
    0xf5, 0x95, 0x48, 0x9e, 0x41, 0x54, 0x73, 0x23, 0x4b, 0xa7, 0x44, 0x88, 0xd2, 0xe9, 0x18, 0xa7,
    0xe4, 0x5b, 0xe9, 0xe3, 0xc4, 0xcc, 0xcb, 0xd9, 0x1f, 0x7d, 0x18, 0xbd, 0xe6, 0x5b, 0x69, 0x8e,
    0x43, 0xc5, 0x3e, 0x54, 0xeb, 0xde, 0x3f, 0xb8, 0x23, 0xe6, 0xf6, 0xb5, 0x0c, 0xcc, 0x79, 0x19,
    0x31, 0x2e, 0x84, 0x49, 0x07, 0xe4, 0x87, 0x32, 0x96, 0xc2, 0x8d, 0xe4, 0x4a, 0xa4, 0x43, 0x2a,
    0x85, 0xb4, 0xe4, 0x6b, 0x88, 0x75, 0x55, 0x16, 0xca, 0x35, 0x42, 0xa6, 0xa3, 0x79, 0xef, 0xbc,
    0xcf, 0x0e, 0x00, 0x26, 0xaf, 0xb9, 0x23, 0xe3, 0xd8, 0x1b, 0x3b, 0x1d, 0x6f, 0x31, 0xce, 0xd6,
    0x69, 0x44, 0xb7, 0xa0, 0xec, 0x33, 0xae, 0xd3, 0x38, 0x64, 0x5c, 0xa3, 0x4f, 0x5d, 0x19, 0x97,
    0x02, 0x65, 0x87, 0x32, 0xc6, 0x6c, 0xac, 0x34, 0xbe, 0x92, 0x89, 0xf7, 0xec, 0x74, 0x22, 0xcb,
    0xda, 0xbb, 0xca, 0x88, 0x74, 0x4a, 0xb6, 0x56, 0xc7, 0x27, 0x5a, 0x19, 0x5e, 0x8a, 0xf4, 0xd4,
    0x1b, 0x48, 0xc1, 0x13, 0x46, 0x5a, 0x69, 0x6e, 0xa5, 0x48, 0x67, 0x74, 0xa2, 0xd5, 0xb3, 0x3f,
    0x7b, 0x30, 0xc0, 0x46, 0xf8, 0xd7, 0x7e, 0x7c, 0x06, 0x11, 0x4a, 0x47, 0xa4, 0x76, 0x7a, 0xf2,
    0x15, 0xc4, 0x6b, 0x23, 0xb9, 0x93, 0x39, 0x77, 0xe1, 0x81, 0x22, 0x02, 0x16, 0xee, 0xc8, 0xb8,
    0xda, 0x07, 0x9a, 0x83, 0xf1, 0x87, 0x3d, 0x1a, 0x9b, 0x5a, 0x84, 0x93, 0xc3, 0x50, 0xa1, 0x07,
    0x16, 0x0e, 0x53, 0x91, 0x25, 0x5f, 0x69, 0x22, 0x3b, 0x62, 0x41, 0x4b, 0xbe, 0x84, 0x48, 0xd9,
    0x9c, 0x6b, 0x6e, 0xb6, 0x9e, 0xe9, 0x88, 0x8d, 0x95, 0x5d, 0xa0, 0x8a, 0x26, 0x21, 0x75, 0xfe,
    0x41, 0xf3, 0xc2, 0x93, 0x1d, 0xb1, 0xb1, 0x90, 0xfa, 0x52, 0xf3, 0x22, 0xfb, 0xab, 0x0f, 0x40,
    0xcd, 0xe2, 0xeb, 0x7c, 0xd8, 0x30, 0xdf, 0x00, 0xac, 0xbd, 0x35, 0xa7, 0x99, 0x43, 0x3c, 0x26,
    0x64, 0x29, 0x6c, 0xf2, 0x05, 0x0d, 0x50, 0xae, 0x44, 0x28, 0xd0, 0xf3, 0xb2, 0xc4, 0xc9, 0x8a,
    0x9d, 0xda, 0xca, 0xdc, 0x34, 0x5a, 0xa6, 0x83, 0xf9, 0xc9, 0xf9, 0xe4, 0xe2, 0xc9, 0x61, 0xb6,
    0xde, 0xf0, 0xfd, 0x6b, 0xa7, 0x59, 0x84, 0x2e, 0xac, 0xd1, 0x12, 0xaf, 0x31, 0x92, 0xaf, 0x1d,
    0xf9, 0x53, 0xc5, 0xb1, 0x47, 0xbc, 0xf9, 0x5b, 0x98, 0x92, 0x59, 0xc8, 0x5b, 0xb5, 0xa6, 0xc2,
    0x63, 0x36, 0xf1, 0xd8, 0x1b, 0x0f, 0xdd, 0x2b, 0x71, 0x7c, 0xaf, 0xc4, 0xe4, 0x39, 0x4c, 0x02,
    0x9b, 0x47, 0x04, 0x00, 0x41, 0xde, 0xe1, 0xc0, 0x68, 0x7c, 0x8f, 0xd1, 0x04, 0x06, 0xf6, 0xa8,
    0xf7, 0x50, 0xc6, 0x8a, 0x95, 0xcd, 0x3f, 0x34, 0x5a, 0xfb, 0xd6, 0x8b, 0xd8, 0x48, 0xd9, 0xcb,
    0x46, 0xeb, 0x24, 0x83, 0x53, 0xad, 0xca, 0x4d, 0x5e, 0x98, 0xaa, 0xa9, 0x91, 0x10, 0xea, 0xbe,
    0x09, 0x82, 0x3f, 0x22, 0xb6, 0x14, 0xd9, 0x15, 0x8c, 0xa8, 0x74, 0xdc, 0x45, 0x82, 0xef, 0xc3,
    0x90, 0xa3, 0x98, 0x5c, 0x00, 0x10, 0x63, 0xbc, 0x2c, 0xa4, 0xdf, 0x6e, 0xf7, 0xd7, 0x11, 0x52,
    0x85, 0x26, 0xe6, 0x89, 0xf5, 0x62, 0xf6, 0x0a, 0xe2, 0x0e, 0xc7, 0xee, 0xb6, 0x8e, 0x1b, 0x17,
    0x5e, 0x8f, 0x14, 0xbc, 0x48, 0x96, 0x22, 0xbc, 0x1c, 0x8a, 0xd9, 0x7b, 0x18, 0xbf, 0xad, 0xf4,
    0xbe, 0xa8, 0xca, 0xff, 0xb5, 0x1e, 0xbe, 0x83, 0x51, 0x5d, 0xa9, 0xd2, 0xd9, 0xf0, 0x8c, 0x9f,
    0x1c, 0x72, 0x7a, 0x8b, 0x38, 0x0b, 0xe6, 0xec, 0x05, 0x0c, 0x3d, 0x90, 0x4c, 0xa1, 0xb7, 0x0b,
    0x41, 0x7b, 0x3b, 0xd4, 0xf6, 0x21, 0x60, 0x6f, 0x9f, 0xfd, 0xdd, 0x87, 0xd9, 0xa1, 0xdd, 0x16,
    0xa6, 0xb0, 0x1f, 0x25, 0x71, 0x06, 0xb3, 0xd0, 0x72, 0x6d, 0x6b, 0xd1, 0xe9, 0xe9, 0xba, 0x3b,
    0xb7, 0x14, 0x7e, 0x7e, 0xda, 0xc6, 0xec, 0x86, 0x2b, 0xf4, 0x25, 0xb6, 0x53, 0x4d, 0x25, 0xa2,
    0x95, 0xa6, 0x2b, 0x0e, 0xc8, 0x52, 0x24, 0x9f, 0xf9, 0x4f, 0x24, 0x0f, 0x9b, 0x0c, 0xa9, 0x12,
    0x18, 0x32, 0x83, 0x53, 0x84, 0xb9, 0x29, 0x72, 0xae, 0x15, 0xb7, 0x6d, 0x9b, 0x59, 0x81, 0x89,
    0x2e, 0x10, 0xc2, 0x79, 0xaf, 0x6a, 0x69, 0xb8, 0xab, 0x8c, 0x6f, 0xb3, 0x98, 0x75, 0x7a, 0xf2,
    0x02, 0x4e, 0x5b, 0x39, 0xf7, 0x1b, 0x95, 0xf6, 0xda, 0xb4, 0x05, 0xdf, 0xe1, 0x66, 0x3d, 0xba,
    0xe4, 0x96, 0xeb, 0x46, 0x86, 0x55, 0x17, 0x2e, 0x79, 0x8f, 0xd0, 0xa3, 0x7d, 0x77, 0x06, 0x33,
    0x9c, 0x8d, 0xfc, 0x4e, 0xb9, 0x9b, 0xbc, 0x94, 0x3b, 0x17, 0x36, 0xdf, 0x14, 0xd1, 0x5f, 0x95,
    0xbb, 0xb9, 0x92, 0x3b, 0x87, 0x53, 0xf0, 0xa0, 0xff, 0xc6, 0x45, 0xe8, 0xbd, 0xdf, 0xfb, 0x70,
    0x72, 0x2d, 0x3e, 0x9e, 0xf0, 0xe7, 0x30, 0x09, 0x8b, 0x08, 0xfb, 0x2a, 0x70, 0x0d, 0x04, 0x61,
    0x73, 0x1d, 0x8d, 0x8f, 0x77, 0x20, 0xae, 0xc3, 0xf8, 0x78, 0x87, 0xff, 0x5c, 0x65, 0xc7, 0x73,
    0x49, 0x6c, 0x77, 0x73, 0x99, 0xc2, 0x98, 0x06, 0x4d, 0x04, 0xa6, 0x5b, 0x15, 0x0f, 0x21, 0x49,
    0xbe, 0x17, 0x89, 0xe5, 0xb1, 0x15, 0x9b, 0xab, 0xf0, 0x5b, 0xa9, 0x75, 0x55, 0xb6, 0x7f, 0x06,
    0xca, 0xd8, 0xe3, 0x8d, 0xd1, 0x81, 0x49, 0x14, 0x93, 0x33, 0x18, 0x70, 0x53, 0xd8, 0x14, 0x1e,
    0x6e, 0x9e, 0x6b, 0x4f, 0x33, 0xf3, 0xd6, 0xec, 0xb7, 0x1e, 0x8c, 0x08, 0xc0, 0xe1, 0xa1, 0x37,
    0xa7, 0xfa, 0x49, 0x79, 0xec, 0x77, 0xed, 0xbe, 0xcb, 0xf0, 0x35, 0xb6, 0xdf, 0xe5, 0xb6, 0xb1,
    0xb4, 0xaa, 0x23, 0xe6, 0x65, 0x8c, 0x48, 0xa3, 0x4c, 0xb5, 0x91, 0xd2, 0x3d, 0xed, 0xf8, 0xf0,
    0xb4, 0xab, 0x91, 0xcf, 0xee, 0xd5, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x9c, 0x23, 0x7c, 0x95,
    0x1b, 0x09, 0x00, 0x00,
}

func (m *TaskLabel) Marshal() (dAtA []byte, err error) {
    size := m.Size()
    dAtA = make([]byte, size)
    n, err := m.MarshalTo(dAtA)
    if err != nil {
        return nil, err
    }
    return dAtA[:n], nil
}

func (m *TaskLabel) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if len(m.Taskid) > 0 {
        dAtA[i] = 0xa
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Taskid)))
        i += copy(dAtA[i:], m.Taskid)
    }
    if len(m.Sdkids) > 0 {
        for _, s := range m.Sdkids {
            dAtA[i] = 0x12
            i++
            l = len(s)
            for l >= 1<<7 {
                dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
                l >>= 7
                i++
            }
            dAtA[i] = uint8(l)
            i++
            i += copy(dAtA[i:], s)
        }
    }
    if m.Index != 0 {
        dAtA[i] = 0x18
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Index))
    }
    return i, nil
}

func (m *SdkMessage) Marshal() (dAtA []byte, err error) {
    size := m.Size()
    dAtA = make([]byte, size)
    n, err := m.MarshalTo(dAtA)
    if err != nil {
        return nil, err
    }
    return dAtA[:n], nil
}

func (m *SdkMessage) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if len(m.Cid) > 0 {
        dAtA[i] = 0xa
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Cid)))
        i += copy(dAtA[i:], m.Cid)
    }
    if m.Tasklab != nil {
        dAtA[i] = 0x12
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Tasklab.Size()))
        n1, err1 := m.Tasklab.MarshalTo(dAtA[i:])
        if err1 != nil {
            return 0, err1
        }
        i += n1
    }
    if len(m.Data) > 0 {
        dAtA[i] = 0x1a
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Data)))
        i += copy(dAtA[i:], m.Data)
    }
    return i, nil
}

func (m *Image) Marshal() (dAtA []byte, err error) {
    size := m.Size()
    dAtA = make([]byte, size)
    n, err := m.MarshalTo(dAtA)
    if err != nil {
        return nil, err
    }
    return dAtA[:n], nil
}

func (m *Image) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if m.Width != 0 {
        dAtA[i] = 0x8
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Width))
    }
    if m.Height != 0 {
        dAtA[i] = 0x10
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Height))
    }
    if len(m.Data) > 0 {
        dAtA[i] = 0x1a
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Data)))
        i += copy(dAtA[i:], m.Data)
    }
    return i, nil
}

func encodeVarintProtomsg(dAtA []byte, offset int, v uint64) int {
    for v >= 1<<7 {
        dAtA[offset] = uint8(v&0x7f | 0x80)
        v >>= 7
        offset++
    }
    dAtA[offset] = uint8(v)
    return offset + 1
}
func (m *TaskLabel) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    l = len(m.Taskid)
    if l > 0 {
        n += 1 + l + sovProtomsg(uint64(l))
    }
    if len(m.Sdkids) > 0 {
        for _, s := range m.Sdkids {
            l = len(s)
            n += 1 + l + sovProtomsg(uint64(l))
        }
    }
    if m.Index != 0 {
        n += 1 + sovProtomsg(uint64(m.Index))
    }
    return n
}

func (m *SdkMessage) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    l = len(m.Cid)
    if l > 0 {
        n += 1 + l + sovProtomsg(uint64(l))
    }
    if m.Tasklab != nil {
        l = m.Tasklab.Size()
        n += 1 + l + sovProtomsg(uint64(l))
    }
    l = len(m.Data)
    if l > 0 {
        n += 1 + l + sovProtomsg(uint64(l))
    }
    return n
}

func (m *Image) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    if m.Width != 0 {
        n += 1 + sovProtomsg(uint64(m.Width))
    }
    if m.Height != 0 {
        n += 1 + sovProtomsg(uint64(m.Height))
    }
    l = len(m.Data)
    if l > 0 {
        n += 1 + l + sovProtomsg(uint64(l))
    }
    return n
}

func sovProtomsg(x uint64) (n int) {
    for {
        n++
        x >>= 7
        if x == 0 {
            break
        }
    }
    return n
}
func sozProtomsg(x uint64) (n int) {
    return sovProtomsg(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *TaskLabel) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
        var wire uint64
        for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
                return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
                return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            wire |= uint64(b&0x7F) << shift
            if b < 0x80 {
                break
            }
        }
        fieldNum := int32(wire >> 3)
        wireType := int(wire & 0x7)
        if wireType == 4 {
            return fmt.Errorf("proto: TaskLabel: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: TaskLabel: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Taskid", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                stringLen |= uint64(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            intStringLen := int(stringLen)
            if intStringLen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.Taskid = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 2:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Sdkids", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                stringLen |= uint64(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            intStringLen := int(stringLen)
            if intStringLen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.Sdkids = append(m.Sdkids, string(dAtA[iNdEx:postIndex]))
            iNdEx = postIndex
        case 3:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
            }
            m.Index = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.Index |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        default:
            iNdEx = preIndex
            skippy, err := skipProtomsg(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) > l {
                return io.ErrUnexpectedEOF
            }
            iNdEx += skippy
        }
    }

    if iNdEx > l {
        return io.ErrUnexpectedEOF
    }
    return nil
}
func (m *SdkMessage) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
        var wire uint64
        for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
                return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
                return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            wire |= uint64(b&0x7F) << shift
            if b < 0x80 {
                break
            }
        }
        fieldNum := int32(wire >> 3)
        wireType := int(wire & 0x7)
        if wireType == 4 {
            return fmt.Errorf("proto: SdkMessage: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: SdkMessage: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Cid", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                stringLen |= uint64(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            intStringLen := int(stringLen)
            if intStringLen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.Cid = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 2:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Tasklab", wireType)
            }
            var msglen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                msglen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if msglen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + msglen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            if m.Tasklab == nil {
                m.Tasklab = &TaskLabel{}
            }
            if err := m.Tasklab.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        case 3:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
            }
            var byteLen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                byteLen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if byteLen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + byteLen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
            if m.Data == nil {
                m.Data = []byte{}
            }
            iNdEx = postIndex
        default:
            iNdEx = preIndex
            skippy, err := skipProtomsg(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) > l {
                return io.ErrUnexpectedEOF
            }
            iNdEx += skippy
        }
    }

    if iNdEx > l {
        return io.ErrUnexpectedEOF
    }
    return nil
}
func (m *Image) Unmarshal(dAtA []byte) error {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        preIndex := iNdEx
        var wire uint64
        for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
                return ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
                return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            wire |= uint64(b&0x7F) << shift
            if b < 0x80 {
                break
            }
        }
        fieldNum := int32(wire >> 3)
        wireType := int(wire & 0x7)
        if wireType == 4 {
            return fmt.Errorf("proto: Image: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: Image: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field Width", wireType)
            }
            m.Width = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.Width |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        case 2:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
            }
            m.Height = 0
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                m.Height |= int32(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
        case 3:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
            }
            var byteLen int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                byteLen |= int(b&0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if byteLen < 0 {
                return ErrInvalidLengthProtomsg
            }
            postIndex := iNdEx + byteLen
            if postIndex < 0 {
                return ErrInvalidLengthProtomsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
            if m.Data == nil {
                m.Data = []byte{}
            }
            iNdEx = postIndex
        default:
            iNdEx = preIndex
            skippy, err := skipProtomsg(dAtA[iNdEx:])
            if err != nil {
                return err
            }
            if skippy < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) < 0 {
                return ErrInvalidLengthProtomsg
            }
            if (iNdEx + skippy) > l {
                return io.ErrUnexpectedEOF
            }
            iNdEx += skippy
        }
    }

    if iNdEx > l {
        return io.ErrUnexpectedEOF
    }
    return nil
}
func skipProtomsg(dAtA []byte) (n int, err error) {
    l := len(dAtA)
    iNdEx := 0
    for iNdEx < l {
        var wire uint64
        for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
                return 0, ErrIntOverflowProtomsg
            }
            if iNdEx >= l {
                return 0, io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            wire |= (uint64(b) & 0x7F) << shift
            if b < 0x80 {
                break
            }
        }
        wireType := int(wire & 0x7)
        switch wireType {
        case 0:
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return 0, ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return 0, io.ErrUnexpectedEOF
                }
                iNdEx++
                if dAtA[iNdEx-1] < 0x80 {
                    break
                }
            }
            return iNdEx, nil
        case 1:
            iNdEx += 8
            return iNdEx, nil
        case 2:
            var length int
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return 0, ErrIntOverflowProtomsg
                }
                if iNdEx >= l {
                    return 0, io.ErrUnexpectedEOF
                }
                b := dAtA[iNdEx]
                iNdEx++
                length |= (int(b) & 0x7F) << shift
                if b < 0x80 {
                    break
                }
            }
            if length < 0 {
                return 0, ErrInvalidLengthProtomsg
            }
            iNdEx += length
            if iNdEx < 0 {
                return 0, ErrInvalidLengthProtomsg
            }
            return iNdEx, nil
        case 3:
            for {
                var innerWire uint64
                var start int = iNdEx
                for shift := uint(0); ; shift += 7 {
                    if shift >= 64 {
                        return 0, ErrIntOverflowProtomsg
                    }
                    if iNdEx >= l {
                        return 0, io.ErrUnexpectedEOF
                    }
                    b := dAtA[iNdEx]
                    iNdEx++
                    innerWire |= (uint64(b) & 0x7F) << shift
                    if b < 0x80 {
                        break
                    }
                }
                innerWireType := int(innerWire & 0x7)
                if innerWireType == 4 {
                    break
                }
                next, err := skipProtomsg(dAtA[start:])
                if err != nil {
                    return 0, err
                }
                iNdEx = start + next
                if iNdEx < 0 {
                    return 0, ErrInvalidLengthProtomsg
                }
            }
            return iNdEx, nil
        case 4:
            return iNdEx, nil
        case 5:
            iNdEx += 4
            return iNdEx, nil
        default:
            return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
        }
    }
    panic("unreachable")
}

var (
    ErrInvalidLengthProtomsg = fmt.Errorf("proto: negative length found during unmarshaling")
    ErrIntOverflowProtomsg   = fmt.Errorf("proto: integer overflow")
)

 protomsg.proto

@@ -19,3 +19,121 @@
    int32 height = 2;
    bytes data = 3;
}

//Area结构体
message Area{
    int32 id = 1;
    int32 parentid = 2;
    string name = 3;
}

//Camera结构体
message Camera {
    string id = 1;
    string name = 2;
    int32 type = 3;
    string addr = 4;
    int32 areaid = 5;
    float longitude = 6;
    float latitude = 7;
    string rtsp = 8;
    string ip = 9;
    int32 port = 10;
    string username = 11;
    string password = 12;
    string brand = 13;
    string reserved = 14;
}

//Task结构体
message Task {
    string taskid = 1;
    string taskname = 2;
    string create_at = 3;
    string create_by = 4;
    string update_at = 5;
    bool enable = 6;
    bool is_alarm = 7;
    bool del_flag = 8;
}

//摄像机任务
message CameraTask {
    string id = 1;
    string camera_ids = 2;//摄像机id
    string task_id = 3;//任务id
    repeated DayCtl time_rule = 4;//布防时间
    string react_rule = 5;//联动方式
    string react_device = 6;//联动设备
    bool del_flag = 7; //逻辑删除标记
    bool update_flag = 8;//是否参数更新了
    bool enable = 9; //是否启用
    int32 sort = 10; //任务排序
    bool is_full = 11;//参数是否设置完整
    string link_group_id = 12;
}

//DayCtl struct   每天的时间控制规则
message DayCtl {
    int32 day = 1;//1-7表示星期一到星期日
    repeated TimeRange time_range = 2;
}

//时间起始范围
message TimeRange {
    string start = 1;//开始
    string end = 2;//结束
}

//Polygon struct
message Polygon {
    string id = 1;//形状id
    string name = 2;//形状的名称
    repeated Point points = 4;//点的集合
}

//Point struct
message Point {
    string x = 1;
    string y = 2;
}

message CameraTaskArgs {
    string id =1;
    string camera_task_id =2;
    string camera_id =3;
    string polygon_id =4;
    string sdk_id = 5;
    string sdk_arg_alias = 6;
    string operator = 7;
    string operator_type = 8;
    string sdk_arg_value = 9;
    int32 sort = 10;
    string rule_with_next = 11;
    string group_id =12;

}

//Sdk struct
message Sdk {
    string id = 1;
    string create_time = 2;
    string update_time = 3;
    string create_by = 4;
    string del_flag = 5;//是否删除
    string enabled = 6;//是否启用
    string sdk_name = 7;//sdk名称
    string icon = 8;//算法图标
    string url = 9;//算法下载地址
    repeated SdkArg args = 10;
}

//SdkArg struct
message SdkArg {
    string alias = 2;//参数别名
    string name = 3;//参数名称
    string type = 4;//参数类型
    bool must = 5;//参数是否必填
    string range = 6;//参数的范围
    int32 sort = 7;//参数排序
}