capacitor-plugin-gpos700 0.1.0

package/README.md

@@ -0,0 +1,47 @@
+# capacitor-plugin-gpos700
+
+Plugin for GPOS700
+
+## Install
+
+```bash
+npm install capacitor-plugin-gpos700
+npx cap sync
+```
+
+## API
+
+<docgen-index>
+
+* [`imprimirTexto(...)`](#imprimirtexto)
+* [`statusImpressora()`](#statusimpressora)
+
+</docgen-index>
+
+<docgen-api>
+<!--Update the source file JSDoc comments and rerun docgen to update the docs below-->
+
+### imprimirTexto(...)
+
+```typescript
+imprimirTexto(options: { mensagem: string; alinhar?: string; size?: number; font?: string; }) => Promise<void>
+```
+
+| Param         | Type                                                                               |
+| ------------- | ---------------------------------------------------------------------------------- |
+| **`options`** | <code>{ mensagem: string; alinhar?: string; size?: number; font?: string; }</code> |
+
+--------------------
+
+
+### statusImpressora()
+
+```typescript
+statusImpressora() => Promise<{ status: string; }>
+```
+
+**Returns:** <code>Promise&lt;{ status: string; }&gt;</code>
+
+--------------------
+
+</docgen-api>

package/android/build.gradle

@@ -0,0 +1,61 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.7.1'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.3.0'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.7.0'
+}
+
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.13.0'
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    namespace = "com.galago.plugins.gpos"
+    compileSdk = project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 36
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 24
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 36
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError = false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_21
+        targetCompatibility JavaVersion.VERSION_21
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+    flatDir {
+        dirs 'libs'
+    }
+}
+
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar', '*.aar'])
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    testImplementation "junit:junit:$junitVersion"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,6 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.galago.plugins.gpos">
+    <uses-permission android:name="android.permission.CAMERA" />
+    <uses-feature android:name="android.hardware.camera" />
+    <uses-feature android:name="android.hardware.camera.autofocus" />
+</manifest>

package/android/src/main/java/com/galago/plugins/gpos/ConfigPrint.java

@@ -0,0 +1,152 @@
+package com.galago.plugins.gpos;
+
+public class ConfigPrint {
+
+    private String fonte = "NORMAL";
+    private String alinhamento;
+    private int tamanho;
+    private int offSet;
+    private int iHeight;
+    private int iWidth;
+    private int lineSpace;
+    private boolean negrito;
+    private boolean italico;
+    private boolean sublinhado;
+    private int avancaLinhas;
+
+    public ConfigPrint() {
+        this.fonte = "NORMAL";
+        this.alinhamento = "CENTER";
+        this.tamanho = 20;
+        this.offSet = 0;
+        this.iHeight = 700;
+        this.iWidth = 430;
+        this.lineSpace = 0;
+        this.negrito = true;
+        this.italico = true;
+        this.sublinhado = false;
+        this.avancaLinhas = 0;
+    }
+
+    public ConfigPrint(String fonte, String alinhamento, int tamanho, int offSet, int lineSpace, boolean negrito, boolean italico, boolean sublinhado) {
+        this.fonte = fonte;
+        this.alinhamento = alinhamento;
+        this.tamanho = tamanho;
+        this.offSet = offSet;
+        this.lineSpace = lineSpace;
+        this.negrito = negrito;
+        this.italico = italico;
+        this.sublinhado = sublinhado;
+    }
+
+    public ConfigPrint(String fonte, String alinhamento, int tamanho, int offSet, int iHeight, int iWidth, int lineSpace, boolean negrito, boolean italico, boolean sublinhado) {
+        this.fonte = fonte;
+        this.alinhamento = alinhamento;
+        this.tamanho = tamanho;
+        this.offSet = offSet;
+        this.iHeight = iHeight;
+        this.iWidth = iWidth;
+        this.lineSpace = lineSpace;
+        this.negrito = negrito;
+        this.italico = italico;
+        this.sublinhado = sublinhado;
+    }
+
+    public String getFonte() {
+        return fonte;
+    }
+
+    public void setFonte(String fonte) {
+        this.fonte = fonte;
+        switch (fonte) {
+            case "NORMAL", "DEFAULT", "DEFAULT BOLD", "MONOSPACE", "SANS SERIF", "SERIF" -> {
+            }
+            default ->
+                setFont(fonte);
+        }
+    }
+
+    public String getAlinhamento() {
+        return alinhamento;
+    }
+
+    public void setAlinhamento(String alinhamento) {
+        this.alinhamento = alinhamento;
+    }
+
+    public int getTamanho() {
+        return tamanho;
+    }
+
+    public void setTamanho(int tamanho) {
+        this.tamanho = tamanho;
+    }
+
+    public int getOffSet() {
+        return offSet;
+    }
+
+    public void setOffSet(int offSet) {
+        this.offSet = offSet;
+    }
+
+    public int getLineSpace() {
+        return lineSpace;
+    }
+
+    public void setLineSpace(int lineSpace) {
+        this.lineSpace = lineSpace;
+    }
+
+    private void setFont(String fonte) {
+        this.fonte = "fonts/" + fonte;
+    }
+
+    public int getiHeight() {
+        return iHeight;
+    }
+
+    public void setiHeight(int iHeight) {
+        this.iHeight = iHeight;
+    }
+
+    public int getiWidth() {
+        return iWidth;
+    }
+
+    public void setiWidth(int iWidth) {
+        this.iWidth = iWidth;
+    }
+
+    public boolean isNegrito() {
+        return negrito;
+    }
+
+    public void setNegrito(boolean negrito) {
+        this.negrito = negrito;
+    }
+
+    public boolean isItalico() {
+        return italico;
+    }
+
+    public void setItalico(boolean italico) {
+        this.italico = italico;
+    }
+
+    public boolean isSublinhado() {
+        return sublinhado;
+    }
+
+    public void setSublinhado(boolean sublinhado) {
+        this.sublinhado = sublinhado;
+    }
+
+    public int getAvancaLinhas() {
+        return avancaLinhas;
+    }
+
+    public void setAvancaLinhas(int avancaLinhas) {
+        this.avancaLinhas = avancaLinhas;
+    }
+}

package/android/src/main/java/com/galago/plugins/gpos/GertecPrinter.java

@@ -0,0 +1,509 @@
+package com.galago.plugins.gpos;
+
+import android.app.Activity;
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Paint;
+import android.graphics.Typeface;
+
+import br.com.gertec.gedi.GEDI;
+import br.com.gertec.gedi.enums.GEDI_PRNTR_e_Alignment;
+import br.com.gertec.gedi.enums.GEDI_PRNTR_e_BarCodeType;
+import br.com.gertec.gedi.enums.GEDI_PRNTR_e_Status;
+import br.com.gertec.gedi.exceptions.GediException;
+import br.com.gertec.gedi.interfaces.IGEDI;
+import br.com.gertec.gedi.interfaces.IPRNTR;
+import br.com.gertec.gedi.structs.GEDI_PRNTR_st_BarCodeConfig;
+import br.com.gertec.gedi.structs.GEDI_PRNTR_st_PictureConfig;
+import br.com.gertec.gedi.structs.GEDI_PRNTR_st_StringConfig;
+
+public class GertecPrinter {
+
+    // Definições
+    private final String IMPRESSORA_ERRO = "Impressora com erro.";
+
+    // Statics
+    private static boolean isPrintInit = false;
+
+    // Vaviáveis iniciais
+    private Activity activity;
+    private Context context;
+
+    // Classe de impressão
+    private IGEDI iGedi = null;
+    private IPRNTR iPrint = null;
+    private GEDI_PRNTR_st_StringConfig stringConfig;
+    private GEDI_PRNTR_st_PictureConfig pictureConfig;
+    private GEDI_PRNTR_e_Status status;
+
+    // Classe de configuração da impressão
+    private ConfigPrint configPrint;
+    private Typeface typeface;
+
+    /**
+     * Método construtor da classe usando o GPOS 700
+     *
+     * @param c = Context atual que esta sendo inicializada a class
+     *
+     */
+    public GertecPrinter(Context c) {
+        this.context = c;
+        startIGEDI();
+    }
+
+    /**
+     * Método que instância a classe GEDI da lib deve ser usado apenas para o
+     * GPOS 700
+     *
+     * @apiNote = Este mátodo faz a instância da classe GEDI através de uma
+     * Thread. Será sempre chamado na construção da classe. Não alterar...
+     *
+     */
+    private void startIGEDI() {
+        new Thread(() -> {
+            GEDI.init(this.context);
+            this.iGedi = GEDI.getInstance(this.context);
+            this.iPrint = this.iGedi.getPRNTR();
+            try {
+                new Thread().sleep(250);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }).start();
+    }
+
+    /**
+     * Método que recebe a configuração para ser usada na impressão
+     *
+     * @param config = Classe {@link ConfigPrint} que contém toda a configuração
+     * para a impressão
+     *
+     */
+    public void setConfigImpressao(ConfigPrint config) {
+
+        this.configPrint = config;
+
+        this.stringConfig = new GEDI_PRNTR_st_StringConfig(new Paint());
+        this.stringConfig.paint.setTextSize(configPrint.getTamanho());
+        this.stringConfig.paint.setTextAlign(Paint.Align.valueOf(configPrint.getAlinhamento()));
+        this.stringConfig.offset = configPrint.getOffSet();
+        this.stringConfig.lineSpace = configPrint.getLineSpace();
+
+        switch (configPrint.getFonte()) {
+            case "NORMAL":
+                this.typeface = Typeface.create(configPrint.getFonte(), Typeface.NORMAL);
+                break;
+            case "DEFAULT":
+                this.typeface = Typeface.create(Typeface.DEFAULT, Typeface.NORMAL);
+                break;
+            case "DEFAULT BOLD":
+                this.typeface = Typeface.create(Typeface.DEFAULT_BOLD, Typeface.NORMAL);
+                break;
+            case "MONOSPACE":
+                this.typeface = Typeface.create(Typeface.MONOSPACE, Typeface.NORMAL);
+                break;
+            case "SANS SERIF":
+                this.typeface = Typeface.create(Typeface.SANS_SERIF, Typeface.NORMAL);
+                break;
+            case "SERIF":
+                this.typeface = Typeface.create(Typeface.SERIF, Typeface.NORMAL);
+                break;
+            default:
+                this.typeface = Typeface.createFromAsset(this.context.getAssets(), configPrint.getFonte());
+        }
+
+        if (this.configPrint.isNegrito() && this.configPrint.isItalico()) {
+            typeface = Typeface.create(typeface, Typeface.BOLD_ITALIC);
+        } else if (this.configPrint.isNegrito()) {
+            typeface = Typeface.create(typeface, Typeface.BOLD);
+        } else if (this.configPrint.isItalico()) {
+            typeface = Typeface.create(typeface, Typeface.ITALIC);
+        }
+
+        if (this.configPrint.isSublinhado()) {
+            this.stringConfig.paint.setFlags(Paint.UNDERLINE_TEXT_FLAG);
+        }
+
+        this.stringConfig.paint.setTypeface(this.typeface);
+    }
+
+    /**
+     * Método que retorna o atual estado da impressora
+     *
+     * @throws GediException = vai retorno o código do erro.
+     *
+     * @return String = traduzStatusImpressora()
+     *
+     *
+     */
+    public String getStatusImpressora() throws GediException {
+        try {
+            ImpressoraInit();
+            this.status = this.iPrint.Status();
+        } catch (GediException e) {
+            throw new GediException(e.getErrorCode());
+        }
+
+        return traduzStatusImpressora(this.status);
+    }
+
+    /**
+     * Método que recebe o atual texto a ser impresso
+     *
+     * @param texto = Texto que será impresso.
+     *
+     * @throws Exception = caso a impressora esteja com erro.
+     *
+     *
+     */
+    public void imprimeTexto(String texto) throws Exception {
+
+        //this.getStatusImpressora();
+        try {
+            if (!isImpressoraOK()) {
+                throw new Exception(IMPRESSORA_ERRO);
+            }
+            sPrintLine(texto);
+        } catch (Exception e) {
+            throw new Exception(e.getMessage());
+        }
+    }
+
+    /**
+     * Método que recebe o atual texto e o tamanho da fonte que deve ser usado
+     * na impressão.
+     *
+     * @param texto = Texto que será impresso.
+     * @param tamanho = Tamanho da fonte que será usada
+     *
+     * @throws Exception = caso a impressora esteja com erro.
+     *
+     * @apiNote = Esse mátodo só altera o tamanho do texto na impressão que for
+     * chamado a classe {@link ConfigPrint} não será alterada para continuar
+     * sendo usado na impressão da proxíma linha
+     *
+     *
+     */
+    public void imprimeTexto(String texto, int tamanho) throws Exception {
+
+        int tamanhoOld;
+
+        //this.getStatusImpressora();
+        try {
+            if (!isImpressoraOK()) {
+                throw new Exception(IMPRESSORA_ERRO);
+            }
+            tamanhoOld = this.configPrint.getTamanho();
+            this.configPrint.setTamanho(tamanho);
+            this.setConfigImpressao(this.configPrint);
+            sPrintLine(texto);
+            this.configPrint.setTamanho(tamanhoOld);
+            this.setConfigImpressao(this.configPrint);
+        } catch (Exception e) {
+            throw new Exception(e.getMessage());
+        }
+    }
+
+    /**
+     * Método que recebe o atual texto e ser o mesmo será impresso em negrito.
+     *
+     * @param texto = Texto que será impresso.
+     * @param negrito = Caso o texto deva ser impresso em negrito
+     *
+     * @throws Exception = caso a impressora esteja com erro.
+     *
+     * @apiNote = Esse mátodo só altera o tamanho do texto na impressão que for
+     * chamado * a classe {@link ConfigPrint} não será alterada para continuar
+     * sendo usado na impressão da * proxíma linha
+     *
+     *
+     */
+    public void imprimeTexto(String texto, boolean negrito) throws Exception {
+
+        boolean negritoOld = false;
+
+        //this.getStatusImpressora();
+        try {
+            if (!isImpressoraOK()) {
+                throw new Exception(IMPRESSORA_ERRO);
+            }
+            negritoOld = this.configPrint.isNegrito();
+            this.configPrint.setNegrito(negrito);
+            this.setConfigImpressao(this.configPrint);
+            sPrintLine(texto);
+
+            this.configPrint.setNegrito(negritoOld);
+            this.setConfigImpressao(this.configPrint);
+
+        } catch (Exception e) {
+            throw new Exception(e.getMessage());
+        }
+    }
+
+    /**
+     * Método que recebe o atual texto e ser o mesmo será impresso em negrito
+     * e/ou itálico.
+     *
+     * @param texto = Texto que será impresso.
+     * @param negrito = Caso o texto deva ser impresso em negrito
+     * @param italico = Caso o texto deva ser impresso em itálico
+     *
+     * @throws Exception = caso a impressora esteja com erro.
+     *
+     * @apiNote = Esse mátodo só altera o tamanho do texto na impressão que for
+     * chamado * a classe {@link ConfigPrint} não será alterada para continuar
+     * sendo usado na impressão da * proxíma linha
+     *
+     *
+     */
+    public void imprimeTexto(String texto, boolean negrito, boolean italico) throws Exception {
+
+        boolean negritoOld = false;
+        boolean italicoOld = false;
+
+        try {
+            if (!isImpressoraOK()) {
+                throw new Exception(IMPRESSORA_ERRO);
+            }
+            negritoOld = this.configPrint.isNegrito();
+            italicoOld = this.configPrint.isItalico();
+            this.configPrint.setNegrito(negrito);
+            this.configPrint.setItalico(italico);
+            this.setConfigImpressao(this.configPrint);
+            sPrintLine(texto);
+
+            this.configPrint.setNegrito(negritoOld);
+            this.configPrint.setItalico(italicoOld);
+            this.setConfigImpressao(this.configPrint);
+
+        } catch (Exception e) {
+            throw new Exception(e.getMessage());
+        }
+    }
+
+    /**
+     * Método que recebe o atual texto e ser o mesmo será impresso em negrito,
+     * itálico e/ou sublinhado.
+     *
+     * @param texto = Texto que será impresso.
+     * @param negrito = Caso o texto deva ser impresso em negrito
+     * @param italico = Caso o texto deva ser impresso em itálico
+     * @param sublinhado = Caso o texto deva ser impresso em itálico.
+     *
+     * @throws Exception = caso a impressora esteja com erro.
+     *
+     * @apiNote = Esse mátodo só altera o tamanho do texto na impressão que for
+     * chamado * a classe {@link ConfigPrint} não será alterada para continuar
+     * sendo usado na impressão da * proxíma linha
+     *
+     *
+     */
+    public void imprimeTexto(String texto, boolean negrito, boolean italico, boolean sublinhado) throws Exception {
+
+        boolean negritoOld = false;
+        boolean italicoOld = false;
+        boolean sublinhadoOld = false;
+
+        try {
+            if (!isImpressoraOK()) {
+                throw new Exception(IMPRESSORA_ERRO);
+            }
+            negritoOld = this.configPrint.isNegrito();
+            italicoOld = this.configPrint.isItalico();
+            sublinhadoOld = this.configPrint.isSublinhado();
+
+            this.configPrint.setNegrito(negrito);
+            this.configPrint.setItalico(italico);
+            this.configPrint.setSublinhado(sublinhado);
+            this.setConfigImpressao(this.configPrint);
+            sPrintLine(texto);
+
+            this.configPrint.setNegrito(negritoOld);
+            this.configPrint.setItalico(italicoOld);
+            this.configPrint.setSublinhado(sublinhadoOld);
+            this.setConfigImpressao(this.configPrint);
+
+        } catch (Exception e) {
+            throw new Exception(e.getMessage());
+        }
+    }
+
+    /**
+     * Método privado que faz a impressão do texto.
+     *
+     * @param texto = Texto que será impresso
+     *
+     * @throws GediException = retorna o código do erro
+     *
+     *
+     */
+    private boolean sPrintLine(String texto) throws Exception {
+        //Print Data
+        try {
+            ImpressoraInit();
+            this.iPrint.DrawStringExt(this.stringConfig, texto);
+            this.avancaLinha(configPrint.getAvancaLinhas());
+            //ImpressoraOutput();
+            return true;
+        } catch (GediException e) {
+            throw new GediException(e.getErrorCode());
+        }
+    }
+
+    /**
+     * Método que faz a impressão de imagens
+     *
+     * @param imagem = Nome da imagem que deve estar na pasta drawable
+     *
+     * @throws IllegalArgumentException = Argumento passado ilegal
+     * @throws GediException = retorna o código do erro.
+     *
+     *
+     */
+    public boolean imprimeImagem(String imagem) throws GediException {
+
+        int id = 0;
+        Bitmap bmp;
+        try {
+
+            pictureConfig = new GEDI_PRNTR_st_PictureConfig();
+
+            // Align
+            pictureConfig.alignment = GEDI_PRNTR_e_Alignment.valueOf(configPrint.getAlinhamento());
+            // Height
+            pictureConfig.height = this.configPrint.getiHeight();
+            // Width
+            pictureConfig.width = this.configPrint.getiWidth();
+
+            if (android.os.Build.MODEL.equals("GPOS700")) {
+                id = context.getResources().getIdentifier(imagem, "drawable",
+                        context.getPackageName());
+                bmp = BitmapFactory.decodeResource(context.getResources(), id);
+            } else {
+                id = this.activity.getApplicationContext().getResources().getIdentifier(
+                        imagem, "drawable",
+                        this.activity.getApplicationContext().getPackageName());
+                bmp = BitmapFactory.decodeResource(this.activity.getApplicationContext().getResources(), id);
+            }
+
+            ImpressoraInit();
+            this.iPrint.DrawPictureExt(pictureConfig, bmp);
+            this.avancaLinha(configPrint.getAvancaLinhas());
+
+            return true;
+        } catch (IllegalArgumentException e) {
+            throw new IllegalArgumentException(e);
+        } catch (GediException e) {
+            throw new GediException(e.getErrorCode());
+        }
+
+    }
+
+    /**
+     * Método que faz o avanço de linhas após uma impressão.
+     *
+     * @param linhas = Número de linhas que dever ser pulado após a impressão.
+     *
+     * @throws GediException = retorna o código do erro.
+     *
+     * @apiNote = Esse método não deve ser chamado dentro de um FOR ou WHILE, o
+     * número de linhas deve ser sempre passado no atributo do método.
+     *
+     *
+     */
+    public void avancaLinha(int linhas) throws GediException {
+        try {
+            if (linhas > 0) {
+                this.iPrint.DrawBlankLine(linhas);
+            }
+        } catch (GediException e) {
+            throw new GediException(e.getErrorCode());
+        }
+    }
+
+    /**
+     * Método que retorno se a impressora está apta a fazer impressões
+     *
+     * @return true = quando estiver tudo ok.
+     *
+     *
+     */
+    public boolean isImpressoraOK() {
+
+        if (status.getValue() == 0) {
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Método que faz a inicialização da impressao
+     *
+     * @throws GediException = retorno o código do erro.
+     *
+     *
+     */
+    public void ImpressoraInit() throws GediException {
+        try {
+            if (this.iPrint != null && !isPrintInit) {
+                this.iPrint.Init();
+                isPrintInit = true;
+            }
+        } catch (GediException e) {
+            e.printStackTrace();
+            throw new GediException(e.getErrorCode());
+        }
+    }
+
+    /**
+     * Método que faz a finalizacao do objeto iPrint
+     *
+     * @throws GediException = retorno o código do erro.
+     *
+     *
+     */
+    public void ImpressoraOutput() throws GediException {
+        try {
+            if (this.iPrint != null) {
+                this.iPrint.Output();
+                isPrintInit = false;
+            }
+        } catch (GediException e) {
+            e.printStackTrace();
+            throw new GediException(e.getErrorCode());
+        }
+    }
+
+    /**
+     * Método que faz a tradução do status atual da impressora.
+     *
+     * @param status = Recebe o {@link GEDI_PRNTR_e_Status} como atributo
+     *
+     * @return String = Retorno o atual status da impressora
+     *
+     *
+     */
+    private String traduzStatusImpressora(GEDI_PRNTR_e_Status status) {
+        String retorno;
+        switch (status) {
+            case OK:
+                retorno = "IMPRESSORA OK";
+                break;
+
+            case OUT_OF_PAPER:
+                retorno = "SEM PAPEL";
+                break;
+
+            case OVERHEAT:
+                retorno = "SUPER AQUECIMENTO";
+                break;
+
+            default:
+                retorno = "ERRO DESCONHECIDO";
+                break;
+        }
+
+        return retorno;
+    }
+}

package/android/src/main/java/com/galago/plugins/gpos/GposPlugin.java

@@ -0,0 +1,60 @@
+package com.galago.plugins.gpos;
+
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+
+@CapacitorPlugin(name = "Gpos")
+public class GposPlugin extends Plugin {
+
+    private GertecPrinter gertecPrinter;
+    private ConfigPrint configPrint = new ConfigPrint();
+
+    @Override
+    public void load() {
+        // Inicializa a impressora usando o contexto do Capacitor
+        gertecPrinter = new GertecPrinter(getContext());
+        gertecPrinter.setConfigImpressao(configPrint);
+    }
+
+    @PluginMethod
+    public void imprimirTexto(PluginCall call) {
+        String mensagem = call.getString("mensagem");
+        String alinhar = call.getString("alinhar", "CENTER");
+        int size = call.getInt("size", 20);
+        String fonte = call.getString("font", "NORMAL"); // Captura a fonte enviada
+
+        try {
+            if (gertecPrinter.isImpressoraOK()) {
+                configPrint.setAlinhamento(alinhar);
+                configPrint.setTamanho(size);
+                configPrint.setFonte(fonte); // Define a fonte na configuração
+                configPrint.setAvancaLinhas(2);
+
+                gertecPrinter.setConfigImpressao(configPrint);
+                gertecPrinter.imprimeTexto(mensagem);
+
+                gertecPrinter.ImpressoraOutput();
+                call.resolve();
+            } else {
+                call.reject("Impressora não está pronta ou sem papel.");
+            }
+        } catch (Exception e) {
+            call.reject("Erro na impressão: " + e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void statusImpressora(PluginCall call) {
+        try {
+            String status = gertecPrinter.getStatusImpressora();
+            JSObject ret = new JSObject();
+            ret.put("status", status);
+            call.resolve(ret);
+        } catch (Exception e) {
+            call.reject(e.getMessage());
+        }
+    }
+}

package/dist/docs.json

@@ -0,0 +1,41 @@
+{
+  "api": {
+    "name": "GposPlugin",
+    "slug": "gposplugin",
+    "docs": "",
+    "tags": [],
+    "methods": [
+      {
+        "name": "imprimirTexto",
+        "signature": "(options: { mensagem: string; alinhar?: string; size?: number; font?: string; }) => Promise<void>",
+        "parameters": [
+          {
+            "name": "options",
+            "docs": "",
+            "type": "{ mensagem: string; alinhar?: string | undefined; size?: number | undefined; font?: string | undefined; }"
+          }
+        ],
+        "returns": "Promise<void>",
+        "tags": [],
+        "docs": "",
+        "complexTypes": [],
+        "slug": "imprimirtexto"
+      },
+      {
+        "name": "statusImpressora",
+        "signature": "() => Promise<{ status: string; }>",
+        "parameters": [],
+        "returns": "Promise<{ status: string; }>",
+        "tags": [],
+        "docs": "",
+        "complexTypes": [],
+        "slug": "statusimpressora"
+      }
+    ],
+    "properties": []
+  },
+  "interfaces": [],
+  "enums": [],
+  "typeAliases": [],
+  "pluginConfigs": []
+}

package/dist/esm/definitions.d.ts

@@ -0,0 +1,11 @@
+export interface GposPlugin {
+    imprimirTexto(options: {
+        mensagem: string;
+        alinhar?: string;
+        size?: number;
+        font?: string;
+    }): Promise<void>;
+    statusImpressora(): Promise<{
+        status: string;
+    }>;
+}

package/dist/esm/definitions.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=definitions.js.map

package/dist/esm/definitions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"","sourcesContent":["export interface GposPlugin {\n  imprimirTexto(options: {\n    mensagem: string;\n    alinhar?: string;\n    size?: number;\n    font?: string; // Adicionado para suportar VECTRA.otf\n  }): Promise<void>;\n\n  statusImpressora(): Promise<{ status: string }>;\n}\n"]}

package/dist/esm/index.d.ts

@@ -0,0 +1,4 @@
+import type { GposPlugin } from './definitions';
+declare const Gpos: GposPlugin;
+export * from './definitions';
+export { Gpos };

package/dist/esm/index.js

@@ -0,0 +1,5 @@
+import { registerPlugin } from '@capacitor/core';
+const Gpos = registerPlugin('Gpos');
+export * from './definitions';
+export { Gpos };
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAIjD,MAAM,IAAI,GAAG,cAAc,CAAa,MAAM,CAAC,CAAC;AAEhD,cAAc,eAAe,CAAC;AAC9B,OAAO,EAAE,IAAI,EAAE,CAAC","sourcesContent":["import { registerPlugin } from '@capacitor/core';\n\nimport type { GposPlugin } from './definitions';\n\nconst Gpos = registerPlugin<GposPlugin>('Gpos');\n\nexport * from './definitions';\nexport { Gpos };\n"]}

package/dist/plugin.cjs.js

@@ -0,0 +1,8 @@
+'use strict';
+
+var core = require('@capacitor/core');
+
+const Gpos = core.registerPlugin('Gpos');
+
+exports.Gpos = Gpos;
+//# sourceMappingURL=plugin.cjs.js.map

package/dist/plugin.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.cjs.js","sources":["esm/index.js"],"sourcesContent":["import { registerPlugin } from '@capacitor/core';\nconst Gpos = registerPlugin('Gpos');\nexport * from './definitions';\nexport { Gpos };\n//# sourceMappingURL=index.js.map"],"names":["registerPlugin"],"mappings":";;;;AACK,MAAC,IAAI,GAAGA,mBAAc,CAAC,MAAM;;;;"}

package/dist/plugin.js

@@ -0,0 +1,11 @@
+var capacitorPluginGpos700 = (function (exports, core) {
+	'use strict';
+
+	const Gpos = core.registerPlugin('Gpos');
+
+	exports.Gpos = Gpos;
+
+	return exports;
+
+})({}, capacitorExports);
+//# sourceMappingURL=plugin.js.map

package/dist/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.js","sources":["esm/index.js"],"sourcesContent":["import { registerPlugin } from '@capacitor/core';\nconst Gpos = registerPlugin('Gpos');\nexport * from './definitions';\nexport { Gpos };\n//# sourceMappingURL=index.js.map"],"names":["registerPlugin"],"mappings":";;;AACK,OAAC,IAAI,GAAGA,mBAAc,CAAC,MAAM;;;;;;;;;;"}

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "capacitor-plugin-gpos700",
+  "version": "0.1.0",
+  "description": "Capacitor plugin for GPOS700 and similar Gertec GPOS devices",
+  "main": "dist/plugin.cjs.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "unpkg": "dist/plugin.js",
+  "files": [
+    "android/src/main/",
+    "android/build.gradle",
+    "dist/",
+    "README.md"
+  ],
+  "author": "Igor Gomes",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/roginaldosemog/capacitor-plugin-gpos700"
+  },
+  "bugs": {
+    "url": "https://github.com/roginaldosemog/capacitor-plugin-gpos700/issues"
+  },
+  "keywords": [
+    "capacitor",
+    "plugin",
+    "native"
+  ],
+  "scripts": {
+    "verify": "npm run verify:android",
+    "verify:android": "cd android && ./gradlew clean build test && cd ..",
+    "lint": "npm run eslint && npm run prettier -- --check",
+    "fmt": "npm run eslint -- --fix && npm run prettier -- --write",
+    "eslint": "eslint . --ext ts",
+    "prettier": "prettier \"**/*.{css,html,ts,js,java}\" --plugin=prettier-plugin-java",
+    "docgen": "docgen --api GposPlugin --output-readme README.md --output-json dist/docs.json",
+    "build": "npm run clean && npm run docgen && tsc && rollup -c rollup.config.mjs",
+    "clean": "rimraf ./dist",
+    "watch": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@capacitor/android": "^8.0.0",
+    "@capacitor/core": "^8.0.0",
+    "@capacitor/docgen": "^0.3.1",
+    "@ionic/eslint-config": "^0.4.0",
+    "@ionic/prettier-config": "^4.0.0",
+    "eslint": "^8.57.1",
+    "prettier": "^3.8.1",
+    "rimraf": "^6.1.0",
+    "rollup": "^4.53.2",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "@capacitor/core": ">=7.0.0"
+  },
+  "prettier": "@ionic/prettier-config",
+  "eslintConfig": {
+    "extends": "@ionic/eslint-config/recommended"
+  },
+  "capacitor": {
+    "android": {
+      "src": "android"
+    }
+  }
+}