- Check for login failure and handle via presenting setting screen

- Handle Kia API endpoint and config entry for manufacturer
- Add VIN to configuration screen / config to handle multiple car situation

Author: andyfase

docs/app-assets/car-images/ev6.png

@@ -13,7 +13,6 @@ import {
   dateStringOptions,
   getChargeCompletionString,
 } from 'lib/util'
-import { initRegionalBluelink } from './lib/bluelink'
 
 interface updatingActions {
   status?: {
@@ -58,8 +57,7 @@ const { present, connect, setState } = getTable<{
 
 const MIN_API_REFRESH_TIME = 900000 // 15 minutes
 
-export async function createApp(config: Config) {
-  const bl = await initRegionalBluelink(config)
+export async function createApp(config: Config, bl: Bluelink) {
   await loadTintedIcons()
 
   // not blocking call - render UI with last cache and then update from a non forced remote call (i.e. to server but not to car)

src/app.ts

@@ -10,15 +10,18 @@ export interface Auth {
 }
 
 export interface Config {
+  manufacturer: string | undefined
   auth: Auth
   tempType: 'C' | 'F'
   climateTempWarm: number
   climateTempCold: number
   allowWidgetRemoteRefresh: boolean
   debugLogging: boolean
+  vin: string | undefined
 }
 
 export interface FlattenedConfig {
+  manufacturer: string | undefined
   username: string
   password: string
   pin: string
@@ -28,9 +31,11 @@ export interface FlattenedConfig {
   climateTempCold: number
   allowWidgetRemoteRefresh: boolean
   debugLogging: boolean
+  vin: string | undefined
 }
 
 const SUPPORTED_REGIONS = ['canada']
+const SUPPORTED_MANUFACTURERS = ['Hyundai', 'Kia']
 
 const DEFAULT_TEMPS = {
   C: {
@@ -55,6 +60,7 @@ const DEFAULT_CONFIG = {
   climateTempWarm: DEFAULT_TEMPS.C.warm,
   debugLogging: false,
   allowWidgetRemoteRefresh: false,
+  manufacturer: undefined,
 } as Config
 
 export function configExists(): boolean {
@@ -83,12 +89,16 @@ export function getConfig(): Config {
   if (Keychain.contains(KEYCHAIN_BLUELINK_CONFIG_KEY)) {
     config = JSON.parse(Keychain.get(KEYCHAIN_BLUELINK_CONFIG_KEY))
   }
-  if (!config) {
+  if (!config || !configValid) {
     config = DEFAULT_CONFIG
   }
   return config
 }
 
+function configValid(config: Config): boolean {
+  return config && Object.hasOwn(config, 'auth')
+}
+
 export async function loadConfigScreen() {
   return await form<FlattenedConfig>({
     title: 'Bluelink Configuration settings',
@@ -103,6 +113,8 @@ export async function loadConfigScreen() {
       climateTempCold,
       debugLogging,
       allowWidgetRemoteRefresh,
+      manufacturer: manufacturer,
+      vin: vin,
     }) => {
       setConfig({
         auth: {
@@ -116,6 +128,8 @@ export async function loadConfigScreen() {
         climateTempWarm: climateTempWarm,
         allowWidgetRemoteRefresh: allowWidgetRemoteRefresh,
         debugLogging: debugLogging,
+        manufacturer: manufacturer?.toLowerCase(),
+        vin: vin ? vin.toUpperCase() : undefined,
       } as Config)
     },
     onStateChange: (state, previousState): Partial<FlattenedConfig> => {
@@ -172,6 +186,18 @@ export async function loadConfigScreen() {
         allowCustom: false,
         isRequired: true,
       },
+      manufacturer: {
+        type: 'dropdown',
+        label: 'Choose your Car Manufacturer',
+        options: SUPPORTED_MANUFACTURERS,
+        allowCustom: false,
+        isRequired: false,
+      },
+      vin: {
+        type: 'textInput',
+        label: 'Optional VIN of car',
+        isRequired: false,
+      },
       tempType: {
         type: 'dropdown',
         label: 'Choose your preferred temperature scale',

src/config.ts

@@ -1,18 +1,36 @@
+import { initRegionalBluelink } from 'lib/bluelink'
 import { createWidget } from 'widget'
 import { createApp } from 'app'
 import { processSiriRequest } from 'siri'
 import { getConfig, loadConfigScreen, configExists } from 'config'
+import { confirm } from './lib/scriptable-utils'
 ;(async () => {
-  if (config.runsInWidget && configExists()) {
-    const widget = await createWidget(getConfig())
+  if (!configExists() && (config.runsWithSiri || config.runsInWidget)) return
+  const blConfig = getConfig()
+  const bl = await initRegionalBluelink(blConfig)
+
+  if (!bl || bl.loginFailed()) {
+    if (config.runsWithSiri || config.runsInWidget) {
+      return
+    }
+    await confirm('Login Failed - please re-check your credentials', {
+      confirmButtonTitle: 'Ok',
+      includeCancel: false,
+    })
+    await loadConfigScreen()
+    return
+  }
+
+  if (config.runsInWidget) {
+    const widget = await createWidget(blConfig, bl)
     Script.setWidget(widget)
     Script.complete()
-  } else if (config.runsWithSiri && configExists()) {
-    Script.setShortcutOutput(await processSiriRequest(getConfig(), args.shortcutParameter))
+  } else if (config.runsWithSiri) {
+    Script.setShortcutOutput(await processSiriRequest(blConfig, bl, args.shortcutParameter))
     Script.complete()
   } else {
     try {
-      const resp = configExists() ? await createApp(getConfig()) : await loadConfigScreen()
+      const resp = await createApp(blConfig, bl)
       // @ts-ignore - undocumented api
       App.close() // add this back after dev
       return resp

src/index.ts

@@ -4,6 +4,7 @@ import PersistedLog from '../scriptable-utils/io/PersistedLog'
 const KEYCHAIN_CACHE_KEY = 'egmp-bluelink-cache'
 export const DEFAULT_STATUS_CHECK_INTERVAL = 3600 * 1000
 const BLUELINK_LOG_FILE = 'egmp-bluelink-log'
+const DEFAULT_API_DOMAIN = 'https://mybluelink.ca/tods/api/'
 
 export interface BluelinkTokens {
   accessToken: string
@@ -77,7 +78,8 @@ export interface ClimateRequest {
 
 const carImageHttpURL = 'https://bluelink.andyfase.com/app-assets/car-images/'
 const carImageMap: Record<string, string> = {
-  ioniq5: 'ioniq5.png',
+  'ioniq 5': 'ioniq5.png',
+  'ev 6': 'ev6.png',
   default: 'ioniq5.png',
 }
 
@@ -88,37 +90,61 @@ export class Bluelink {
   protected cache: Cache
   protected vin: string | undefined
   protected statusCheckInterval: number
+  protected apiDomain: string
 
   protected additionalHeaders: Record<string, string>
   protected authHeader: string
   protected tempLookup: TempConversion | undefined
   protected tokens: BluelinkTokens | undefined
   protected debugLastRequest: DebugLastRequest | undefined
   protected logger: any
+  protected loginFailure: boolean
 
   constructor(config: Config, vin?: string) {
     this.vin = vin
+    this.apiDomain = DEFAULT_API_DOMAIN
     this.statusCheckInterval = DEFAULT_STATUS_CHECK_INTERVAL
     this.additionalHeaders = {}
     this.authHeader = 'Authentication'
     this.tokens = undefined
+    this.loginFailure = false
     this.debugLastRequest = undefined
     this.tempLookup = undefined
     this.logger = PersistedLog(BLUELINK_LOG_FILE)
   }
 
-  protected async superInit(config: Config, vin?: string, statusCheckInterval?: number) {
+  protected async superInit(config: Config, statusCheckInterval?: number) {
     this.config = config
-    this.vin = vin
+    this.vin = this.config.vin
     this.statusCheckInterval = statusCheckInterval || DEFAULT_STATUS_CHECK_INTERVAL
 
-    this.cache = await this.loadCache()
+    const cache = await this.loadCache()
+    if (!cache) {
+      this.loginFailure = true
+      return
+    }
+    this.cache = cache
     if (!this.tokenValid()) {
-      this.cache.token = await this.login()
-      this.saveCache()
+      const tokens = await this.login()
+      if (!tokens) this.loginFailure = true
+      else {
+        this.tokens = tokens
+        this.saveCache()
+      }
     }
   }
 
+  protected getApiDomain(lookup: string, domains: Record<string, string>, _default: string): string {
+    for (const [key, domain] of Object.entries(domains)) {
+      if (key === lookup) return domain
+    }
+    return _default
+  }
+
+  public loginFailed(): boolean {
+    return this.loginFailure
+  }
+
   public getCachedStatus(): Status {
     return {
       car: this.cache.car,
@@ -216,14 +242,19 @@ export class Bluelink {
     Keychain.set(KEYCHAIN_CACHE_KEY, JSON.stringify(this.cache))
   }
 
-  protected async loadCache(): Promise<Cache> {
+  protected async loadCache(): Promise<Cache | undefined> {
     let cache: Cache | undefined = undefined
     if (Keychain.contains(KEYCHAIN_CACHE_KEY)) {
       cache = JSON.parse(Keychain.get(KEYCHAIN_CACHE_KEY))
     }
     if (!cache) {
       // initial use - load car and status
-      this.tokens = await this.login()
+      const tokens = await this.login()
+      if (!tokens) {
+        this.loginFailure = true
+        return
+      }
+      this.tokens = tokens
       const car = await this.getCar()
       cache = {
         token: this.tokens,
@@ -314,7 +345,7 @@ export class Bluelink {
     })
   }
 
-  protected async login(): Promise<BluelinkTokens> {
+  protected async login(): Promise<BluelinkTokens | undefined> {
     // implemented in country specific sub-class
     throw Error('Not Implemented')
   }