Merge branch 'master' of ssh://192.168.1.14:29418/pubsub/protomsg

554325746@qq.com

2019-07-11 4484c3b1b058eddc2474db0946069c32df17a773

Merge branch 'master' of ssh://192.168.1.14:29418/pubsub/protomsg

 commsg.pb.go

@@ -8,6 +8,7 @@
    proto "github.com/gogo/protobuf/proto"
    io "io"
    math "math"
    math_bits "math/bits"
)

// Reference imports to suppress errors if they are not otherwise used.
@@ -22,9 +23,8 @@
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package

type SdkmsgWithTask struct {
    Sdkid   string `protobuf:"bytes,1,opt,name=sdkid,proto3" json:"sdkid,omitempty"`
    Ipcid   string `protobuf:"bytes,1,opt,name=ipcid,proto3" json:"ipcid,omitempty"`
    Sdktype string `protobuf:"bytes,2,opt,name=sdktype,proto3" json:"sdktype,omitempty"`
    SdkName string `protobuf:"bytes,3,opt,name=sdkName,proto3" json:"sdkName,omitempty"`
    Sdkdata []byte `protobuf:"bytes,4,opt,name=sdkdata,proto3" json:"sdkdata,omitempty"`
}

@@ -61,9 +61,9 @@

var xxx_messageInfo_SdkmsgWithTask proto.InternalMessageInfo

func (m *SdkmsgWithTask) GetSdkid() string {
func (m *SdkmsgWithTask) GetIpcid() string {
    if m != nil {
        return m.Sdkid
        return m.Ipcid
    }
    return ""
}
@@ -71,13 +71,6 @@
func (m *SdkmsgWithTask) GetSdktype() string {
    if m != nil {
        return m.Sdktype
    }
    return ""
}

func (m *SdkmsgWithTask) GetSdkName() string {
    if m != nil {
        return m.SdkName
    }
    return ""
}
@@ -295,28 +288,27 @@
func init() { proto.RegisterFile("commsg.proto", fileDescriptor_968fba5e415d8aac) }

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

func (m *SdkmsgWithTask) Marshal() (dAtA []byte, err error) {
@@ -334,23 +326,17 @@
    _ = i
    var l int
    _ = l
    if len(m.Sdkid) > 0 {
    if len(m.Ipcid) > 0 {
        dAtA[i] = 0xa
        i++
        i = encodeVarintCommsg(dAtA, i, uint64(len(m.Sdkid)))
        i += copy(dAtA[i:], m.Sdkid)
        i = encodeVarintCommsg(dAtA, i, uint64(len(m.Ipcid)))
        i += copy(dAtA[i:], m.Ipcid)
    }
    if len(m.Sdktype) > 0 {
        dAtA[i] = 0x12
        i++
        i = encodeVarintCommsg(dAtA, i, uint64(len(m.Sdktype)))
        i += copy(dAtA[i:], m.Sdktype)
    }
    if len(m.SdkName) > 0 {
        dAtA[i] = 0x1a
        i++
        i = encodeVarintCommsg(dAtA, i, uint64(len(m.SdkName)))
        i += copy(dAtA[i:], m.SdkName)
    }
    if len(m.Sdkdata) > 0 {
        dAtA[i] = 0x22
@@ -505,15 +491,11 @@
    }
    var l int
    _ = l
    l = len(m.Sdkid)
    l = len(m.Ipcid)
    if l > 0 {
        n += 1 + l + sovCommsg(uint64(l))
    }
    l = len(m.Sdktype)
    if l > 0 {
        n += 1 + l + sovCommsg(uint64(l))
    }
    l = len(m.SdkName)
    if l > 0 {
        n += 1 + l + sovCommsg(uint64(l))
    }
@@ -597,14 +579,7 @@
}

func sovCommsg(x uint64) (n int) {
    for {
        n++
        x >>= 7
        if x == 0 {
            break
        }
    }
    return n
    return (math_bits.Len64(x|1) + 6) / 7
}
func sozCommsg(x uint64) (n int) {
    return sovCommsg(uint64((x << 1) ^ uint64((int64(x) >> 63))))
@@ -640,7 +615,7 @@
        switch fieldNum {
        case 1:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Sdkid", wireType)
                return fmt.Errorf("proto: wrong wireType = %d for field Ipcid", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
@@ -668,7 +643,7 @@
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.Sdkid = string(dAtA[iNdEx:postIndex])
            m.Ipcid = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 2:
            if wireType != 2 {
@@ -701,38 +676,6 @@
                return io.ErrUnexpectedEOF
            }
            m.Sdktype = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 3:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field SdkName", wireType)
            }
            var stringLen uint64
            for shift := uint(0); ; shift += 7 {
                if shift >= 64 {
                    return ErrIntOverflowCommsg
                }
                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 ErrInvalidLengthCommsg
            }
            postIndex := iNdEx + intStringLen
            if postIndex < 0 {
                return ErrInvalidLengthCommsg
            }
            if postIndex > l {
                return io.ErrUnexpectedEOF
            }
            m.SdkName = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 4:
            if wireType != 2 {

 commsg.proto

@@ -3,9 +3,8 @@
package protomsg;

message SdkmsgWithTask {
    string sdkid = 1;
    string ipcid = 1;
    string sdktype = 2;
    string sdkName = 3;
    bytes  sdkdata = 4;
}


 protomsg.pb.go

@@ -565,6 +565,110 @@
    return nil
}

type SdkRun struct {
    IpcId   string `protobuf:"bytes,1,opt,name=ipc_id,json=ipcId,proto3" json:"ipc_id,omitempty"`
    SdkType string `protobuf:"bytes,2,opt,name=sdk_type,json=sdkType,proto3" json:"sdk_type,omitempty"`
}

func (m *SdkRun) Reset()         { *m = SdkRun{} }
func (m *SdkRun) String() string { return proto.CompactTextString(m) }
func (*SdkRun) ProtoMessage()    {}
func (*SdkRun) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{5}
}
func (m *SdkRun) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
}
func (m *SdkRun) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    if deterministic {
        return xxx_messageInfo_SdkRun.Marshal(b, m, deterministic)
    } else {
        b = b[:cap(b)]
        n, err := m.MarshalTo(b)
        if err != nil {
            return nil, err
        }
        return b[:n], nil
    }
}
func (m *SdkRun) XXX_Merge(src proto.Message) {
    xxx_messageInfo_SdkRun.Merge(m, src)
}
func (m *SdkRun) XXX_Size() int {
    return m.Size()
}
func (m *SdkRun) XXX_DiscardUnknown() {
    xxx_messageInfo_SdkRun.DiscardUnknown(m)
}

var xxx_messageInfo_SdkRun proto.InternalMessageInfo

func (m *SdkRun) GetIpcId() string {
    if m != nil {
        return m.IpcId
    }
    return ""
}

func (m *SdkRun) GetSdkType() string {
    if m != nil {
        return m.SdkType
    }
    return ""
}

type TaskSdkRun struct {
    Task *Task     `protobuf:"bytes,1,opt,name=task,proto3" json:"task,omitempty"`
    Sdks []*SdkRun `protobuf:"bytes,2,rep,name=sdks,proto3" json:"sdks,omitempty"`
}

func (m *TaskSdkRun) Reset()         { *m = TaskSdkRun{} }
func (m *TaskSdkRun) String() string { return proto.CompactTextString(m) }
func (*TaskSdkRun) ProtoMessage()    {}
func (*TaskSdkRun) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{6}
}
func (m *TaskSdkRun) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
}
func (m *TaskSdkRun) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    if deterministic {
        return xxx_messageInfo_TaskSdkRun.Marshal(b, m, deterministic)
    } else {
        b = b[:cap(b)]
        n, err := m.MarshalTo(b)
        if err != nil {
            return nil, err
        }
        return b[:n], nil
    }
}
func (m *TaskSdkRun) XXX_Merge(src proto.Message) {
    xxx_messageInfo_TaskSdkRun.Merge(m, src)
}
func (m *TaskSdkRun) XXX_Size() int {
    return m.Size()
}
func (m *TaskSdkRun) XXX_DiscardUnknown() {
    xxx_messageInfo_TaskSdkRun.DiscardUnknown(m)
}

var xxx_messageInfo_TaskSdkRun proto.InternalMessageInfo

func (m *TaskSdkRun) GetTask() *Task {
    if m != nil {
        return m.Task
    }
    return nil
}

func (m *TaskSdkRun) GetSdks() []*SdkRun {
    if m != nil {
        return m.Sdks
    }
    return nil
}

//摄像机任务
type CameraTask struct {
    Id          string    `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
@@ -585,7 +689,7 @@
func (m *CameraTask) String() string { return proto.CompactTextString(m) }
func (*CameraTask) ProtoMessage()    {}
func (*CameraTask) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{5}
    return fileDescriptor_32de24555f916688, []int{7}
}
func (m *CameraTask) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -709,7 +813,7 @@
func (m *CameraTimerule) String() string { return proto.CompactTextString(m) }
func (*CameraTimerule) ProtoMessage()    {}
func (*CameraTimerule) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{6}
    return fileDescriptor_32de24555f916688, []int{8}
}
func (m *CameraTimerule) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -769,7 +873,7 @@
func (m *DayCtl) String() string { return proto.CompactTextString(m) }
func (*DayCtl) ProtoMessage()    {}
func (*DayCtl) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{7}
    return fileDescriptor_32de24555f916688, []int{9}
}
func (m *DayCtl) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -822,7 +926,7 @@
func (m *TimeRange) String() string { return proto.CompactTextString(m) }
func (*TimeRange) ProtoMessage()    {}
func (*TimeRange) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{8}
    return fileDescriptor_32de24555f916688, []int{10}
}
func (m *TimeRange) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -876,7 +980,7 @@
func (m *Polygon) String() string { return proto.CompactTextString(m) }
func (*Polygon) ProtoMessage()    {}
func (*Polygon) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{9}
    return fileDescriptor_32de24555f916688, []int{11}
}
func (m *Polygon) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -935,7 +1039,7 @@
func (m *CameraTaskArgs) String() string { return proto.CompactTextString(m) }
func (*CameraTaskArgs) ProtoMessage()    {}
func (*CameraTaskArgs) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{10}
    return fileDescriptor_32de24555f916688, []int{12}
}
func (m *CameraTaskArgs) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -988,7 +1092,7 @@
func (m *TaskGroupArgs) String() string { return proto.CompactTextString(m) }
func (*TaskGroupArgs) ProtoMessage()    {}
func (*TaskGroupArgs) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{11}
    return fileDescriptor_32de24555f916688, []int{13}
}
func (m *TaskGroupArgs) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -1050,7 +1154,7 @@
func (m *GroupRule) String() string { return proto.CompactTextString(m) }
func (*GroupRule) ProtoMessage()    {}
func (*GroupRule) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{12}
    return fileDescriptor_32de24555f916688, []int{14}
}
func (m *GroupRule) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -1133,7 +1237,7 @@
func (m *Rule) String() string { return proto.CompactTextString(m) }
func (*Rule) ProtoMessage()    {}
func (*Rule) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{13}
    return fileDescriptor_32de24555f916688, []int{15}
}
func (m *Rule) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -1249,23 +1353,24 @@
//Sdk struct
type Sdk struct {
    Id         string    `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
    SdkType    string    `protobuf:"bytes,2,opt,name=sdk_type,json=sdkType,proto3" json:"sdk_type,omitempty"`
    SdkName    string    `protobuf:"bytes,3,opt,name=sdk_name,json=sdkName,proto3" json:"sdk_name,omitempty"`
    Args       []*SdkArg `protobuf:"bytes,4,rep,name=args,proto3" json:"args,omitempty"`
    Icon       string    `protobuf:"bytes,5,opt,name=icon,proto3" json:"icon,omitempty"`
    Url        string    `protobuf:"bytes,6,opt,name=url,proto3" json:"url,omitempty"`
    CreateTime string    `protobuf:"bytes,7,opt,name=create_time,json=createTime,proto3" json:"create_time,omitempty"`
    UpdateTime string    `protobuf:"bytes,8,opt,name=update_time,json=updateTime,proto3" json:"update_time,omitempty"`
    CreateBy   string    `protobuf:"bytes,9,opt,name=create_by,json=createBy,proto3" json:"create_by,omitempty"`
    Enable     bool      `protobuf:"varint,10,opt,name=enable,proto3" json:"enable,omitempty"`
    DelFlag    int32     `protobuf:"varint,11,opt,name=del_flag,json=delFlag,proto3" json:"del_flag,omitempty"`
    IpcId      string    `protobuf:"bytes,2,opt,name=ipc_id,json=ipcId,proto3" json:"ipc_id,omitempty"`
    SdkType    string    `protobuf:"bytes,3,opt,name=sdk_type,json=sdkType,proto3" json:"sdk_type,omitempty"`
    SdkName    string    `protobuf:"bytes,4,opt,name=sdk_name,json=sdkName,proto3" json:"sdk_name,omitempty"`
    Args       []*SdkArg `protobuf:"bytes,5,rep,name=args,proto3" json:"args,omitempty"`
    Icon       string    `protobuf:"bytes,6,opt,name=icon,proto3" json:"icon,omitempty"`
    Url        string    `protobuf:"bytes,7,opt,name=url,proto3" json:"url,omitempty"`
    CreateTime string    `protobuf:"bytes,8,opt,name=create_time,json=createTime,proto3" json:"create_time,omitempty"`
    UpdateTime string    `protobuf:"bytes,9,opt,name=update_time,json=updateTime,proto3" json:"update_time,omitempty"`
    CreateBy   string    `protobuf:"bytes,10,opt,name=create_by,json=createBy,proto3" json:"create_by,omitempty"`
    Enable     bool      `protobuf:"varint,11,opt,name=enable,proto3" json:"enable,omitempty"`
    DelFlag    int32     `protobuf:"varint,12,opt,name=del_flag,json=delFlag,proto3" json:"del_flag,omitempty"`
}

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{14}
    return fileDescriptor_32de24555f916688, []int{16}
}
func (m *Sdk) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -1297,6 +1402,13 @@
func (m *Sdk) GetId() string {
    if m != nil {
        return m.Id
    }
    return ""
}

func (m *Sdk) GetIpcId() string {
    if m != nil {
        return m.IpcId
    }
    return ""
}
@@ -1386,7 +1498,7 @@
func (m *SdkArg) String() string { return proto.CompactTextString(m) }
func (*SdkArg) ProtoMessage()    {}
func (*SdkArg) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{15}
    return fileDescriptor_32de24555f916688, []int{17}
}
func (m *SdkArg) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -1476,7 +1588,7 @@
func (m *DbChangeMessage) String() string { return proto.CompactTextString(m) }
func (*DbChangeMessage) ProtoMessage()    {}
func (*DbChangeMessage) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{16}
    return fileDescriptor_32de24555f916688, []int{18}
}
func (m *DbChangeMessage) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -1548,7 +1660,7 @@
func (m *CameraPolygon) String() string { return proto.CompactTextString(m) }
func (*CameraPolygon) ProtoMessage()    {}
func (*CameraPolygon) Descriptor() ([]byte, []int) {
    return fileDescriptor_32de24555f916688, []int{17}
    return fileDescriptor_32de24555f916688, []int{19}
}
func (m *CameraPolygon) XXX_Unmarshal(b []byte) error {
    return m.Unmarshal(b)
@@ -1641,6 +1753,8 @@
    proto.RegisterType((*CameraAndTaskInfo)(nil), "protomsg.CameraAndTaskInfo")
    proto.RegisterType((*Task)(nil), "protomsg.Task")
    proto.RegisterType((*TaskSdkInfo)(nil), "protomsg.TaskSdkInfo")
    proto.RegisterType((*SdkRun)(nil), "protomsg.SdkRun")
    proto.RegisterType((*TaskSdkRun)(nil), "protomsg.TaskSdkRun")
    proto.RegisterType((*CameraTask)(nil), "protomsg.CameraTask")
    proto.RegisterType((*CameraTimerule)(nil), "protomsg.CameraTimerule")
    proto.RegisterType((*DayCtl)(nil), "protomsg.DayCtl")
@@ -1659,105 +1773,108 @@
func init() { proto.RegisterFile("protomsg.proto", fileDescriptor_32de24555f916688) }

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

func (m *Area) Marshal() (dAtA []byte, err error) {
@@ -2088,6 +2205,76 @@
            return 0, err2
        }
        i += n2
    }
    if len(m.Sdks) > 0 {
        for _, msg := range m.Sdks {
            dAtA[i] = 0x12
            i++
            i = encodeVarintProtomsg(dAtA, i, uint64(msg.Size()))
            n, err := msg.MarshalTo(dAtA[i:])
            if err != nil {
                return 0, err
            }
            i += n
        }
    }
    return i, nil
}

func (m *SdkRun) 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 *SdkRun) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if len(m.IpcId) > 0 {
        dAtA[i] = 0xa
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.IpcId)))
        i += copy(dAtA[i:], m.IpcId)
    }
    if len(m.SdkType) > 0 {
        dAtA[i] = 0x12
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.SdkType)))
        i += copy(dAtA[i:], m.SdkType)
    }
    return i, nil
}

func (m *TaskSdkRun) 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 *TaskSdkRun) MarshalTo(dAtA []byte) (int, error) {
    var i int
    _ = i
    var l int
    _ = l
    if m.Task != nil {
        dAtA[i] = 0xa
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.Task.Size()))
        n3, err3 := m.Task.MarshalTo(dAtA[i:])
        if err3 != nil {
            return 0, err3
        }
        i += n3
    }
    if len(m.Sdks) > 0 {
        for _, msg := range m.Sdks {
@@ -2603,21 +2790,27 @@
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Id)))
        i += copy(dAtA[i:], m.Id)
    }
    if len(m.SdkType) > 0 {
    if len(m.IpcId) > 0 {
        dAtA[i] = 0x12
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.IpcId)))
        i += copy(dAtA[i:], m.IpcId)
    }
    if len(m.SdkType) > 0 {
        dAtA[i] = 0x1a
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.SdkType)))
        i += copy(dAtA[i:], m.SdkType)
    }
    if len(m.SdkName) > 0 {
        dAtA[i] = 0x1a
        dAtA[i] = 0x22
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.SdkName)))
        i += copy(dAtA[i:], m.SdkName)
    }
    if len(m.Args) > 0 {
        for _, msg := range m.Args {
            dAtA[i] = 0x22
            dAtA[i] = 0x2a
            i++
            i = encodeVarintProtomsg(dAtA, i, uint64(msg.Size()))
            n, err := msg.MarshalTo(dAtA[i:])
@@ -2628,37 +2821,37 @@
        }
    }
    if len(m.Icon) > 0 {
        dAtA[i] = 0x2a
        dAtA[i] = 0x32
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Icon)))
        i += copy(dAtA[i:], m.Icon)
    }
    if len(m.Url) > 0 {
        dAtA[i] = 0x32
        dAtA[i] = 0x3a
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.Url)))
        i += copy(dAtA[i:], m.Url)
    }
    if len(m.CreateTime) > 0 {
        dAtA[i] = 0x3a
        dAtA[i] = 0x42
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.CreateTime)))
        i += copy(dAtA[i:], m.CreateTime)
    }
    if len(m.UpdateTime) > 0 {
        dAtA[i] = 0x42
        dAtA[i] = 0x4a
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.UpdateTime)))
        i += copy(dAtA[i:], m.UpdateTime)
    }
    if len(m.CreateBy) > 0 {
        dAtA[i] = 0x4a
        dAtA[i] = 0x52
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(len(m.CreateBy)))
        i += copy(dAtA[i:], m.CreateBy)
    }
    if m.Enable {
        dAtA[i] = 0x50
        dAtA[i] = 0x58
        i++
        if m.Enable {
            dAtA[i] = 1
@@ -2668,7 +2861,7 @@
        i++
    }
    if m.DelFlag != 0 {
        dAtA[i] = 0x58
        dAtA[i] = 0x60
        i++
        i = encodeVarintProtomsg(dAtA, i, uint64(m.DelFlag))
    }
@@ -3028,6 +3221,42 @@
    return n
}

func (m *SdkRun) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    l = len(m.IpcId)
    if l > 0 {
        n += 1 + l + sovProtomsg(uint64(l))
    }
    l = len(m.SdkType)
    if l > 0 {
        n += 1 + l + sovProtomsg(uint64(l))
    }
    return n
}

func (m *TaskSdkRun) Size() (n int) {
    if m == nil {
        return 0
    }
    var l int
    _ = l
    if m.Task != nil {
        l = m.Task.Size()
        n += 1 + l + sovProtomsg(uint64(l))
    }
    if len(m.Sdks) > 0 {
        for _, e := range m.Sdks {
            l = e.Size()
            n += 1 + l + sovProtomsg(uint64(l))
        }
    }
    return n
}

func (m *CameraTask) Size() (n int) {
    if m == nil {
        return 0
@@ -3295,6 +3524,10 @@
    var l int
    _ = l
    l = len(m.Id)
    if l > 0 {
        n += 1 + l + sovProtomsg(uint64(l))
    }
    l = len(m.IpcId)
    if l > 0 {
        n += 1 + l + sovProtomsg(uint64(l))
    }
@@ -4634,6 +4867,246 @@
                return io.ErrUnexpectedEOF
            }
            m.Sdks = append(m.Sdks, &Sdk{})
            if err := m.Sdks[len(m.Sdks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            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 *SdkRun) 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: SdkRun: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: SdkRun: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field IpcId", 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.IpcId = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 2:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field SdkType", 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.SdkType = string(dAtA[iNdEx:postIndex])
            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 *TaskSdkRun) 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: TaskSdkRun: wiretype end group for non-group")
        }
        if fieldNum <= 0 {
            return fmt.Errorf("proto: TaskSdkRun: illegal tag %d (wire type %d)", fieldNum, wire)
        }
        switch fieldNum {
        case 1:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Task", 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.Task == nil {
                m.Task = &Task{}
            }
            if err := m.Task.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
            iNdEx = postIndex
        case 2:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Sdks", 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
            }
            m.Sdks = append(m.Sdks, &SdkRun{})
            if err := m.Sdks[len(m.Sdks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
                return err
            }
@@ -6510,6 +6983,38 @@
            iNdEx = postIndex
        case 2:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field IpcId", 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.IpcId = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 3:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field SdkType", wireType)
            }
            var stringLen uint64
@@ -6540,7 +7045,7 @@
            }
            m.SdkType = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 3:
        case 4:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field SdkName", wireType)
            }
@@ -6572,7 +7077,7 @@
            }
            m.SdkName = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 4:
        case 5:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Args", wireType)
            }
@@ -6606,7 +7111,7 @@
                return err
            }
            iNdEx = postIndex
        case 5:
        case 6:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Icon", wireType)
            }
@@ -6638,7 +7143,7 @@
            }
            m.Icon = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 6:
        case 7:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field Url", wireType)
            }
@@ -6670,7 +7175,7 @@
            }
            m.Url = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 7:
        case 8:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field CreateTime", wireType)
            }
@@ -6702,7 +7207,7 @@
            }
            m.CreateTime = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 8:
        case 9:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field UpdateTime", wireType)
            }
@@ -6734,7 +7239,7 @@
            }
            m.UpdateTime = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 9:
        case 10:
            if wireType != 2 {
                return fmt.Errorf("proto: wrong wireType = %d for field CreateBy", wireType)
            }
@@ -6766,7 +7271,7 @@
            }
            m.CreateBy = string(dAtA[iNdEx:postIndex])
            iNdEx = postIndex
        case 10:
        case 11:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field Enable", wireType)
            }
@@ -6786,7 +7291,7 @@
                }
            }
            m.Enable = bool(v != 0)
        case 11:
        case 12:
            if wireType != 0 {
                return fmt.Errorf("proto: wrong wireType = %d for field DelFlag", wireType)
            }

 protomsg.proto

@@ -61,6 +61,16 @@
    repeated Sdk sdks = 2;
}

message SdkRun {
    string ipc_id = 1;
    string sdk_type = 2;
}

message TaskSdkRun {
    Task task = 1;
    repeated SdkRun sdks = 2;
}

//摄像机任务
message CameraTask {
    string id = 1;
@@ -140,16 +150,17 @@
//Sdk struct
message Sdk {
    string id = 1;
    string sdk_type = 2;//算法类型
    string sdk_name = 3;//sdk名称
    repeated SdkArg args = 4;//算法参数
    string icon = 5;//算法图标
    string url = 6;//算法下载地址
    string create_time = 7;
    string update_time = 8;
    string create_by = 9;
    bool enable = 10;//是否启用
    int32 del_flag = 11;//是否删除
    string ipc_id = 2;
    string sdk_type = 3;//算法类型
    string sdk_name = 4;//sdk名称
    repeated SdkArg args = 5;//算法参数
    string icon = 6;//算法图标
    string url = 7;//算法下载地址
    string create_time = 8;
    string update_time = 9;
    string create_by = 10;
    bool enable = 11;//是否启用
    int32 del_flag = 12;//是否删除
}

//SdkArg struct