Ejemplo n.º 1
0
// Init invokes a set of methods that will make the initial setup of the modem.
func (p *DefaultProfile) Init(d *Device) (err error) {
	p.dev = d
	p.dev.Send(NoopCmd) // kinda flush
	if err = p.COPS(true, true); err != nil {
		return errors.New("at init: unable to adjust the format of operator's name")
	}
	var info *SystemInfoReport
	if info, err = p.SYSINFO(); err != nil {
		return errors.New("at init: unable to read system info")
	}
	p.dev.State = &DeviceState{
		ServiceState:  info.ServiceState,
		ServiceDomain: info.ServiceDomain,
		RoamingState:  info.RoamingState,
		SystemMode:    info.SystemMode,
		SystemSubmode: info.SystemSubmode,
		SimState:      info.SimState,
	}
	if p.dev.State.OperatorName, err = p.OperatorName(); err != nil {
		return errors.New("at init: unable to read operator's name")
	}
	if p.dev.State.ModelName, err = p.ModelName(); err != nil {
		return errors.New("at init: unable to read modem's model name")
	}
	if p.dev.State.IMEI, err = p.IMEI(); err != nil {
		return errors.New("at init: unable to read modem's IMEI code")
	}
	if err = p.CMGF(false); err != nil {
		return errors.New("at init: unable to switch message format to PDU")
	}
	if err = p.CPMS(MemoryTypes.NvRAM, MemoryTypes.NvRAM, MemoryTypes.NvRAM); err != nil {
		return errors.New("at init: unable to set messages storage")
	}
	if err = p.CNMI(1, 1, 0, 0, 0); err != nil {
		return errors.New("at init: unable to turn on message notifications")
	}
	var octets map[uint64][]byte
	if octets, err = p.CMGL(MessageFlags.Any); err != nil {
		return errors.New("at init: unable to check message inbox")
	}
	for n, oct := range octets {
		var msg sms.Message
		if _, err := msg.ReadFrom(oct); err != nil {
			return errors.New("at init: error while parsing message inbox")
		}
		if err := p.CMGD(n, DeleteOptions.Index); err != nil {
			return errors.New("at init: error while cleaning message inbox")
		}
		d.messages <- &msg
	}
	return nil
}
Ejemplo n.º 2
0
// SendLongSMS sends an SMS message with given text to the given address,
// the encoding and other parameters are default.
// If the message is very long, it will be sent in parts.
func (d *Device) SendLongSMS(text string, address sms.PhoneNumber) (err error) {
	defer func() {
		multipartReferenceNumber = uint16((uint32(multipartReferenceNumber) + 1) & 0xFFFF)
	}()

	msg := sms.Message{
		Text:     text,
		Type:     sms.MessageTypes.Submit,
		Encoding: sms.Encodings.Gsm7Bit,
		Address:  address,
		VPFormat: sms.ValidityPeriodFormats.Relative,
		VP:       sms.ValidityPeriod(24 * time.Hour * 4),
	}
	maxSize := 130
	for _, w := range text {
		// detected a double-width char
		if w > 1 {
			msg.Encoding = sms.Encodings.UCS2
			maxSize = 60
			break
		}
	}

	msgParts := util.SplitStringBySize(text, maxSize)
	numberOfParts := byte(255)
	if len(msgParts) <= 255 {
		numberOfParts = byte(len(msgParts))
	}
	msg.UserDataStartsWithHeader = numberOfParts > 1
	for index, part := range msgParts {
		msg.MessageReference = messageReferenceCounter
		msg.Text = part
		if msg.Encoding == sms.Encodings.UCS2 {
		}
		if numberOfParts > 1 {
			msg.UserDataHeader.ConcatenationIE = sms.ConcatenationInformationElement{NumberOfParts: numberOfParts, PartNumber: byte(index + 1), ReferenceNumber: multipartReferenceNumber}
		}
		messageReferenceCounter = byte((uint16(messageReferenceCounter) + 1) & 0xFF)

		if index >= int(numberOfParts) {
			break
		}

		n, octets, err := msg.PDU()
		if err != nil {
			return err
		}
		if err = d.Commands.CMGS(n, octets); err != nil {
			return err
		}
	}

	return
}
Ejemplo n.º 3
0
// SendSMS sends an SMS message with given text to the given address,
// the encoding and other parameters are default.
func (d *Device) SendSMS(text string, address sms.PhoneNumber) (err error) {
	msg := sms.Message{
		Text:     text,
		Type:     sms.MessageTypes.Submit,
		Encoding: sms.Encodings.Gsm7Bit,
		Address:  address,
		VPFormat: sms.ValidityPeriodFormats.Relative,
		VP:       sms.ValidityPeriod(24 * time.Hour * 4),
	}
	for _, w := range text {
		// detected a double-width char
		if w > 1 {
			msg.Encoding = sms.Encodings.UCS2
			break
		}
	}
	n, octets, err := msg.PDU()
	if err != nil {
		return err
	}
	err = d.Commands.CMGS(n, octets)
	return
}
Ejemplo n.º 4
0
// handleReport detects and parses a report from the notification port represented
// as a string. The parsed values may change the inner state or be sent over out channels.
func (d *Device) handleReport(str string) (err error) {
	report := Reports.Resolve(str)
	str = strings.TrimSpace(strings.TrimPrefix(str, report.ID))
	switch report {
	case Reports.Message:
		var report messageReport
		if err = report.Parse(str); err != nil {
			return
		}
		var octets []byte
		octets, err = d.Commands.CMGR(report.Index)
		if err != nil {
			return
		}
		if err = d.Commands.CMGD(report.Index, DeleteOptions.Index); err != nil {
			return
		}
		var msg sms.Message
		if _, err = msg.ReadFrom(octets); err != nil {
			return
		}
		d.messages <- &msg
	case Reports.Ussd:
		var ussd ussdReport
		if err = ussd.Parse(str); err != nil {
			return
		}
		var text string
		if ussd.Enc == Encodings.UCS2 {
			text, err = pdu.DecodeUcs2(ussd.Octets)
			if err != nil {
				return
			}
		} else if ussd.Enc == Encodings.Gsm7Bit {
			text, err = pdu.Decode7Bit(ussd.Octets)
			if err != nil {
				return
			}
		} else {
			return ErrUnknownEncoding
		}
		d.ussd <- Ussd(text)
	case Reports.SignalStrength:
		var rssi signalStrengthReport
		if err = rssi.Parse(str); err != nil {
			return
		}
		if d.State.SignalStrength != int(rssi) {
			d.State.SignalStrength = int(rssi)
			d.updated <- struct{}{}
		}
	case Reports.Mode:
		var report modeReport
		if err = report.Parse(str); err != nil {
			return
		}
		var updated bool
		if d.State.SystemMode != report.Mode {
			d.State.SystemMode = report.Mode
			updated = true
		}
		if d.State.SystemSubmode != report.Submode {
			d.State.SystemSubmode = report.Submode
			updated = true
		}
		if updated {
			d.updated <- struct{}{}
		}
	case Reports.ServiceState:
		var report serviceStateReport
		if err = report.Parse(str); err != nil {
			return
		}
		if d.State.ServiceState != Opt(report) {
			d.State.ServiceState = Opt(report)
			d.updated <- struct{}{}
		}
	case Reports.SimState:
		var report simStateReport
		if err = report.Parse(str); err != nil {
			return
		}
		if d.State.SimState != Opt(report) {
			d.State.SimState = Opt(report)
			d.updated <- struct{}{}
		}
	case Reports.BootHandshake:
		var token bootHandshakeReport
		if err = token.Parse(str); err != nil {
			return
		}
		if err = d.Commands.BOOT(uint64(token)); err != nil {
			return
		}
	case Reports.Stin:
		// ignore. what is this btw?
	default:
		switch FinalResults.Resolve(str) {
		case FinalResults.Noop, FinalResults.NotSupported, FinalResults.Timeout:
			// ignore
		default:
			return errors.New("at: unknown report: " + str)
		}
	}
	return
}