Golang network.Device类代码示例

func (p *Mpris) SendRequest(device *network.Device, playerList bool, volume bool, nowPlaying bool) error {
	return device.Send(MprisType, &MprisBody{
		RequestPlayerList: playerList,
		RequestVolume:     volume,
		RequestNowPlaying: nowPlaying,
	})
}

func (e *Engine) sendIdentity(device *network.Device) error {
	return device.Send(protocol.IdentityType, &protocol.Identity{
		DeviceId:        e.config.DeviceId,
		DeviceName:      e.config.DeviceName,
		ProtocolVersion: protocol.Version,
		DeviceType:      e.config.DeviceType,
		TcpPort:         e.config.TcpPort,
	})
}

func (e *Engine) PairDevice(device *network.Device) error {
	if device.Paired {
		return nil
	}

	if !device.PairRequestSent {
		pair := &protocol.Pair{
			Pair: true,
		}

		pub, err := e.config.PrivateKey.PublicKey().Marshal()
		if err != nil {
			return err
		}
		pair.PublicKey = string(pub)

		err = device.Send(protocol.PairType, pair)
		if err != nil {
			return err
		}

		log.Println("Sent pairing request to", device.Name)

		device.PairRequestSent = true
	}

	if device.PairRequestReceived && device.PairRequestSent {
		device.Paired = true

		log.Println("Device", device.Name, "paired")

		if e.getKnownDevice(device) == -1 {
			// Add it to the list of known devices
			e.config.KnownDevices = append(e.config.KnownDevices, NewKnownDeviceFromDevice(device))
		}

		select {
		case e.Paired <- device:
		default:
		}
	}

	return nil
}

func (e *Engine) UnpairDevice(device *network.Device) error {
	if device.Paired {
		err := device.Send(protocol.PairType, &protocol.Pair{
			Pair: false,
		})
		if err != nil {
			return err
		}

		device.Paired = false
	}

	select {
	case e.Unpaired <- device:
	default:
	}

	return nil
}

func (p *Ping) SendPing(device *network.Device) error {
	return device.Send(PingType, nil)
}

func setDeviceIdentity(device *network.Device, identity *protocol.Identity) {
	device.Id = identity.DeviceId
	device.Name = identity.DeviceName
	device.Type = identity.DeviceType
	device.ProtocolVersion = identity.ProtocolVersion
}

func (e *Engine) handleDevice(device *network.Device) {
	e.devices[device.Id] = device

	if i := e.getKnownDevice(device); i != -1 {
		device.Paired = true
		//device.PublicKey = e.config.KnownDevices[i].PublicKey
	}

	select {
	case e.Joins <- device:
	default:
	}

	go device.Listen()
	go e.sendIdentity(device)

	for pkg := range device.Incoming {
		if pkg == nil {
			continue
		}

		// Decrypt package if encrypted
		if pkg.Type == protocol.EncryptedType {
			var err error
			pkg, err = pkg.Body.(*protocol.Encrypted).Decrypt(e.config.PrivateKey)
			if err != nil {
				log.Println("Cannot decrypt package:", err)
				continue
			}
		}

		if pkg.Type == protocol.PairType {
			pair := pkg.Body.(*protocol.Pair)

			if pair.Pair {
				// Remote asks pairing
				device.PairRequestReceived = true

				if len(pair.PublicKey) > 0 {
					// Remote sent its public key
					pub := &crypto.PublicKey{}

					if err := pub.Unmarshal([]byte(pair.PublicKey)); err != nil {
						log.Println("Cannot parse public key:", err)
						break
					}
					log.Println("Received public key")

					device.PublicKey = pub
				}

				if device.PairRequestSent {
					// We asked for pairing first, remote accepted
					log.Println("Device accepted pairing")

					e.PairDevice(device)
				} else {
					log.Println("Device requested pairing")

					select {
					case e.RequestsPairing <- device:
					default:
					}
				}
			} else {
				log.Println("Device requested unpairing")

				device.Paired = false
				e.UnpairDevice(device)
			}
		} else if pkg.Type == protocol.IdentityType {
			setDeviceIdentity(device, pkg.Body.(*protocol.Identity))
		} else {
			err := e.handler.Handle(device, pkg)
			if err != nil {
				log.Println("Error handling package:", err, pkg.Type, string(pkg.RawBody))
			}
		}
	}

	log.Println("Closed TCP connection")

	delete(e.devices, device.Id)

	select {
	case e.Leaves <- device:
	default:
	}
}

func (p *Mpris) SendSeek(device *network.Device, seek float64) error {
	return device.Send(MprisType, &MprisBody{
		Seek: seek,
	})
}

func (p *Mpris) SendSetPosition(device *network.Device, position float64) error {
	return device.Send(MprisType, &MprisBody{
		SetPosition: position,
	})
}

func (p *Mpris) SendSetVolume(device *network.Device, volume int) error {
	return device.Send(MprisType, &MprisBody{
		SetVolume: volume,
	})
}

func (p *Mpris) SendAction(device *network.Device, action string) error {
	return device.Send(MprisType, &MprisBody{Action: action})
}

func (p *Mpris) SendPlayerList(device *network.Device, playerList []string) error {
	return device.Send(MprisType, &MprisBody{PlayerList: playerList})
}

func (p *Battery) SendRequest(device *network.Device) error {
	return device.Send(BatteryType, &BatteryBody{Request: true})
}

func (p *Notification) SendRequest(device *network.Device) error {
	return device.Send(NotificationType, &NotificationBody{Request: true})
}

func (p *Sftp) SendStartBrowsing(device *network.Device) error {
	return device.Send(SftpType, &SftpBody{StartBrowsing: true})
}