improved sessionName + NewClient + InMemorySessionName

client.go

@@ -116,6 +116,72 @@ func NewClient(appId int, apiHash string, cType ClientType, opts *ClientOpts) (*
 		}
 	}
 
+	var sessionStorage telegram.SessionStorage
+	if opts.Session == nil || opts.Session.GetName() == sessionMaker.InMemorySessionName {
+		sessionStorage = &session.StorageMemory{}
+		storage.Load("", true)
+	} else {
+		sessionStorage = &sessionMaker.SessionStorage{
+			Session: opts.Session,
+		}
+	}
+
+	d := dispatcher.NewNativeDispatcher(opts.AutoFetchReply)
+
+	// client := telegram.NewClient(appId, apiHash, telegram.Options{
+	// 	DCList:         opts.DCList,
+	// 	UpdateHandler:  d,
+	// 	SessionStorage: sessionStorage,
+	// 	Logger:         opts.Logger,
+	// 	Device: telegram.DeviceConfig{
+	// 		DeviceModel:    "GoTGProto",
+	// 		SystemVersion:  runtime.GOOS,
+	// 		AppVersion:     VERSION,
+	// 		SystemLangCode: opts.SystemLangCode,
+	// 		LangCode:       opts.ClientLangCode,
+	// 	},
+	// })
+
+	ctx, cancel := context.WithCancel(context.Background())
+
+	c := Client{
+		Resolver:         opts.Resolver,
+		PublicKeys:       opts.PublicKeys,
+		DC:               opts.DC,
+		DCList:           opts.DCList,
+		DisableCopyright: opts.DisableCopyright,
+		Logger:           opts.Logger,
+		SystemLangCode:   opts.SystemLangCode,
+		ClientLangCode:   opts.ClientLangCode,
+		Dispatcher:       d,
+		sessionStorage:   sessionStorage,
+		clientType:       cType,
+		ctx:              ctx,
+		autoFetchReply:   opts.AutoFetchReply,
+		cancel:           cancel,
+		appId:            appId,
+		apiHash:          apiHash,
+	}
+
+	c.printCredit()
+
+	return &c, c.Start(nil)
+}
+
+func NewClientWithCustomDevice(
+	appId int,
+	apiHash string,
+	cType ClientType,
+	opts *ClientOpts,
+	device *telegram.DeviceConfig,
+) (*Client, error) {
+	if opts == nil {
+		opts = &ClientOpts{
+			SystemLangCode: "en",
+			ClientLangCode: "en",
+		}
+	}
+
 	var sessionStorage telegram.SessionStorage
 	if opts.Session == nil || opts.Session.GetName() == ":memory:" {
 		sessionStorage = &session.StorageMemory{}
@@ -165,22 +231,25 @@ func NewClient(appId int, apiHash string, cType ClientType, opts *ClientOpts) (*
 
 	c.printCredit()
 
-	return &c, c.Start()
+	return &c, c.Start(device)
 }
 
-func (c *Client) initTelegramClient() {
-	c.Client = telegram.NewClient(c.appId, c.apiHash, telegram.Options{
-		DCList:         c.DCList,
-		UpdateHandler:  c.Dispatcher,
-		SessionStorage: c.sessionStorage,
-		Logger:         c.Logger,
-		Device: telegram.DeviceConfig{
+func (c *Client) initTelegramClient(device *telegram.DeviceConfig) {
+	if device == nil {
+		device = &telegram.DeviceConfig{
 			DeviceModel:    "GoTGProto",
 			SystemVersion:  runtime.GOOS,
 			AppVersion:     VERSION,
 			SystemLangCode: c.SystemLangCode,
 			LangCode:       c.ClientLangCode,
-		},
+		}
+	}
+	c.Client = telegram.NewClient(c.appId, c.apiHash, telegram.Options{
+		DCList:         c.DCList,
+		UpdateHandler:  c.Dispatcher,
+		SessionStorage: c.sessionStorage,
+		Logger:         c.Logger,
+		Device:         *device,
 	})
 }
 
@@ -291,14 +360,14 @@ func (c *Client) Stop() {
 
 // Start connects the client to telegram servers and logins.
 // It will return error if the client is already running.
-func (c *Client) Start() error {
+func (c *Client) Start(device *telegram.DeviceConfig) error {
 	if c.running {
 		return intErrors.ErrClientAlreadyRunning
 	}
 	if c.ctx.Err() == context.Canceled {
 		c.ctx, c.cancel = context.WithCancel(context.Background())
 	}
-	c.initTelegramClient()
+	c.initTelegramClient(device)
 	wg := sync.WaitGroup{}
 	wg.Add(1)
 	go func(c *Client) {

sessionMaker/sessionName.go

@@ -30,6 +30,8 @@ const (
 	TelethonSession
 	// PyrogramSession is used as SessionType when you want to log in through the string session made by pyrogram - a Python MTProto library.
 	PyrogramSession
+	// InMemorySessionName is used when it is necessary to indicate that this session is in memory
+	InMemorySessionName = ":memory:"
 )
 
 // NewSession creates a new session with provided name string and SessionType.
@@ -42,50 +44,88 @@ func NewSession(sessionName string, sessionType SessionType) *SessionName {
 	return &s
 }
 
+func NewSessionWithoutFiles(sessionValue string, sessionType SessionType) *SessionName {
+	s := SessionName{
+		name:        InMemorySessionName,
+		sessionType: sessionType,
+	}
+	s.data, s.err = s.loadInMemory(sessionValue)
+	return &s
+}
+
 func (s *SessionName) load() ([]byte, error) {
 	switch s.sessionType {
 	case PyrogramSession:
 		storage.Load("pyrogram.session", false)
-		sd, err := DecodePyrogramSession(s.name)
-		if err != nil {
-			return nil, err
-		}
-		data, err := json.Marshal(jsonData{
-			Version: storage.LatestVersion,
-			Data:    *sd,
-		})
-		return data, err
+		return loadByPyrogramSession(s.name)
 	case TelethonSession:
 		storage.Load("telethon.session", false)
-		sd, err := session.TelethonSession(s.name)
-		if err != nil {
-			return nil, err
-		}
-		data, err := json.Marshal(jsonData{
-			Version: storage.LatestVersion,
-			Data:    *sd,
-		})
-		return data, err
+		return loadByTelethonSession(s.name)
 	case StringSession:
 		storage.Load("gotgproto.session", false)
-		sd, err := functions.DecodeStringToSession(s.name)
-		if err != nil {
-			return nil, err
-		}
-
-		// data, err := json.Marshal(jsonData{
-		// 	Version: latestVersion,
-		// 	Data:    *sd,
-		// })
-		return sd.Data, err
+		return loadByStringSession(s.name)
+	default:
+		return loadByDefault(s.name)
+	}
+}
+
+func (s *SessionName) loadInMemory(sessionValue string) ([]byte, error) {
+	switch s.sessionType {
+	case PyrogramSession:
+		return loadByPyrogramSession(sessionValue)
+	case TelethonSession:
+		return loadByTelethonSession(sessionValue)
+	case StringSession:
+		return loadByStringSession(sessionValue)
 	default:
-		if s.name == "" {
-			s.name = "new"
-		}
-		storage.Load(fmt.Sprintf("%s.session", s.name), false)
-		sFD := storage.GetSession()
-		return sFD.Data, nil
+		return loadByDefault(sessionValue)
+	}
+}
+
+func loadByPyrogramSession(value string) ([]byte, error) {
+	sd, err := DecodePyrogramSession(value)
+	if err != nil {
+		return nil, err
+	}
+	data, err := json.Marshal(jsonData{
+		Version: storage.LatestVersion,
+		Data:    *sd,
+	})
+	return data, err
+}
+
+func loadByTelethonSession(value string) ([]byte, error) {
+	sd, err := session.TelethonSession(value)
+	if err != nil {
+		return nil, err
+	}
+	data, err := json.Marshal(jsonData{
+		Version: storage.LatestVersion,
+		Data:    *sd,
+	})
+	return data, err
+}
+
+func loadByStringSession(value string) ([]byte, error) {
+	sd, err := functions.DecodeStringToSession(value)
+	if err != nil {
+		return nil, err
+	}
+
+	// data, err := json.Marshal(jsonData{
+	// 	Version: latestVersion,
+	// 	Data:    *sd,
+	// })
+	return sd.Data, err
+}
+
+func loadByDefault(value string) ([]byte, error) {
+	if value == "" {
+		value = "new"
 	}
+	storage.Load(fmt.Sprintf("%s.session", value), false)
+	sFD := storage.GetSession()
+	return sFD.Data, nil
 }
 
 // GetName is used for retrieving name of the session.