/* * Copyright (C) 2016 The Android Open Source Project * Copyright (C) 2014-2016 Mopria Alliance, Inc. * Copyright (C) 2013 Hewlett-Packard Development Company, L.P. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include "lib_wprint.h" #include "wprint_debug.h" #include #include "../plugins/wprint_mupdf.h" #define TAG "wprintJNI" #define MAX_NUM_PAGES 2000 static jclass _LocalJobParamsClass; static jfieldID _LocalJobParamsField__borderless; static jfieldID _LocalJobParamsField__duplex; static jfieldID _LocalJobParamsField__media_size; static jfieldID _LocalJobParamsField__media_type; static jfieldID _LocalJobParamsField__media_tray; static jfieldID _LocalJobParamsField__color_space; static jfieldID _LocalJobParamsField__render_flags; static jfieldID _LocalJobParamsField__num_copies; static jfieldID _LocalJobParamsField__page_range; static jfieldID _LocalJobParamsField__print_resolution; static jfieldID _LocalJobParamsField__printable_width; static jfieldID _LocalJobParamsField__printable_height; static jfieldID _LocalJobParamsField__page_width; static jfieldID _LocalJobParamsField__page_height; static jfieldID _LocalJobParamsField__page_margin_top; static jfieldID _LocalJobParamsField__page_margin_left; static jfieldID _LocalJobParamsField__page_margin_right; static jfieldID _LocalJobParamsField__page_margin_bottom; static jfieldID _LocalJobParamsField__job_margin_top; static jfieldID _LocalJobParamsField__job_margin_left; static jfieldID _LocalJobParamsField__job_margin_right; static jfieldID _LocalJobParamsField__job_margin_bottom; static jfieldID _LocalJobParamsField__fit_to_page; static jfieldID _LocalJobParamsField__fill_page; static jfieldID _LocalJobParamsField__auto_rotate; static jfieldID _LocalJobParamsField__portrait_mode; static jfieldID _LocalJobParamsField__landscape_mode; static jfieldID _LocalJobParamsField__nativeData; static jfieldID _LocalJobParamsField__document_category; static jfieldID _LocalJobParamsField__alignment; static jfieldID _LocalJobParamsField__document_scaling; static jfieldID _LocalJobParamsField__job_name; static jfieldID _LocalJobParamsField__job_originating_user_name; static jfieldID _LocalJobParamsField__pdf_render_resolution; static jclass _LocalPrinterCapabilitiesClass; static jfieldID _LocalPrinterCapabilitiesField__name; static jfieldID _LocalPrinterCapabilitiesField__path; static jfieldID _LocalPrinterCapabilitiesField__uuid; static jfieldID _LocalPrinterCapabilitiesField__location; static jfieldID _LocalPrinterCapabilitiesField__duplex; static jfieldID _LocalPrinterCapabilitiesField__borderless; static jfieldID _LocalPrinterCapabilitiesField__color; static jfieldID _LocalPrinterCapabilitiesField__isSupported; static jfieldID _LocalPrinterCapabilitiesField__mediaDefault; static jfieldID _LocalPrinterCapabilitiesField__supportedMediaTypes; static jfieldID _LocalPrinterCapabilitiesField__supportedMediaSizes; static jfieldID _LocalPrinterCapabilitiesField__nativeData; static jfieldID _LocalPrinterCapabilitiesField__certificate; static jclass _JobCallbackClass; static jobject _callbackReceiver; static jmethodID _JobCallbackMethod__jobCallback; static jclass _JobCallbackParamsClass; static jmethodID _JobCallbackParamsMethod__init; static jfieldID _JobCallbackParamsField__jobId; static jfieldID _JobCallbackParamsField__jobState; static jfieldID _JobCallbackParamsField__jobDoneResult; static jfieldID _JobCallbackParamsField__blockedReasons; static jfieldID _JobCallbackParamsField__certificate; static jclass _PrintServiceStringsClass; static jfieldID _PrintServiceStringsField__JOB_STATE_QUEUED; static jfieldID _PrintServiceStringsField__JOB_STATE_RUNNING; static jfieldID _PrintServiceStringsField__JOB_STATE_BLOCKED; static jfieldID _PrintServiceStringsField__JOB_STATE_DONE; static jfieldID _PrintServiceStringsField__JOB_STATE_OTHER; static jfieldID _PrintServiceStringsField__JOB_DONE_OK; static jfieldID _PrintServiceStringsField__JOB_DONE_ERROR; static jfieldID _PrintServiceStringsField__JOB_DONE_CANCELLED; static jfieldID _PrintServiceStringsField__JOB_DONE_CORRUPT; static jfieldID _PrintServiceStringsField__JOB_DONE_OTHER; static jfieldID _PrintServiceStringsField__BLOCKED_REASON__OFFLINE; static jfieldID _PrintServiceStringsField__BLOCKED_REASON__BUSY; static jfieldID _PrintServiceStringsField__BLOCKED_REASON__CANCELLED; static jfieldID _PrintServiceStringsField__BLOCKED_REASON__OUT_OF_PAPER; static jfieldID _PrintServiceStringsField__BLOCKED_REASON__OUT_OF_INK; static jfieldID _PrintServiceStringsField__BLOCKED_REASON__OUT_OF_TONER; static jfieldID _PrintServiceStringsField__BLOCKED_REASON__JAMMED; static jfieldID _PrintServiceStringsField__BLOCKED_REASON__DOOR_OPEN; static jfieldID _PrintServiceStringsField__BLOCKED_REASON__SERVICE_REQUEST; static jfieldID _PrintServiceStringsField__BLOCKED_REASON__LOW_ON_INK; static jfieldID _PrintServiceStringsField__BLOCKED_REASON__LOW_ON_TONER; static jfieldID _PrintServiceStringsField__BLOCKED_REASON__REALLY_LOW_ON_INK; static jfieldID _PrintServiceStringsField__BLOCKED_REASON__BAD_CERTIFICATE; static jfieldID _PrintServiceStringsField__BLOCKED_REASON__UNKNOWN; static jfieldID _PrintServiceStringsField__ALIGNMENT__CENTER; static jfieldID _PrintServiceStringsField__ALIGNMENT__CENTER_HORIZONTAL; static jfieldID _PrintServiceStringsField__ALIGNMENT__CENTER_VERTICAL; static jfieldID _PrintServiceStringsField__ALIGNMENT__CENTER_HORIZONTAL_ON_ORIENTATION; // Global so it can be used in PDF render code JavaVM *_JVM = NULL; static jstring _fakeDir; int g_API_version = 0; /* * Convert char * to a java object */ static void stringToJava(JNIEnv *env, jobject obj, jfieldID id, const char *str); /* * Retuns if the mime type is MIME_TYPE_PDF */ static bool _is_pdf_doc(const char *mime_type, const char *pathname) { if (mime_type == NULL || pathname == NULL) { return false; } if (strcmp(mime_type, MIME_TYPE_PDF) == 0) { return true; } return false; } /* * Returns if the string is numeric */ static int _isNumeric(const char *s) { if (s == NULL || *s == '\0' || isspace(*s)) { return 0; } char *p; strtod(s, &p); return *p == '\0'; } /* * Outputs the number of pages in a pdf to page_count. Returns False if an error ocurred */ static bool _get_pdf_page_count(const char *mime_type, int *page_count, const char *pathname) { *page_count = 0; if (!_is_pdf_doc(mime_type, pathname)) { return false; } pdf_render_ifc_t *pdf_render_ifc = create_pdf_render_ifc(); *page_count = pdf_render_ifc->openDocument(pdf_render_ifc, pathname); pdf_render_ifc->destroy(pdf_render_ifc); LOGI("pdf page count for %s: %d", pathname, *page_count); if (*page_count < 0) { LOGE("page count error"); *page_count = 0; } return true; } /* * Reorders pdf pages before sending to the printer. In general the last page is printed first. * Removes pages from pages_ary if they are not in the specified range. */ static bool _order_pdf_pages(int num_pages, int *pages_ary, int *num_index, char *page_range_split) { bool succeeded = false; char num_begin_ary[5] = ""; char num_end_ary[5] = ""; int num_counter = 0; bool dash_encountered = false; int range_count = 0; // initialize to 0 memset(num_begin_ary, 0, 5); memset(num_end_ary, 0, 5); for (range_count = 0; range_count < (int) strlen(page_range_split); range_count++) { // skip spaces if (!isspace(page_range_split[range_count])) { // store first number found in range in num_begin_ary // and second number (after the dash '-') in num_end_ary // skip the dash ('-') character if (page_range_split[range_count] == '-') { dash_encountered = true; num_counter = 0; continue; } if (!dash_encountered) { num_begin_ary[num_counter++] = page_range_split[range_count]; } else { num_end_ary[num_counter++] = page_range_split[range_count]; } } } // fill in first cell of end num with 0 so array has a valid number if (!dash_encountered) { num_end_ary[0] = '0'; } // make sure numeric values are stored in num_begin_ary and num_end_ary if (_isNumeric(num_begin_ary) && _isNumeric(num_end_ary)) { // convert to integers int num_begin = atoi(num_begin_ary); int num_end = atoi(num_end_ary); // if ending number was 0, there was no range, only a single page number // so, set it to the value of the beginning number if (num_end == 0) { num_end = num_begin; } // make sure beginning and ending numbers are at least 1 if (num_begin > 0 && num_end > 0) { // make sure the beginning and ending numbers are not greater than the page count if (num_begin <= num_pages && num_end <= num_pages) { if (num_end >= num_begin) { // make sure the upper bound does not exceed the number of pages if (num_end > num_pages) { num_end = num_pages; } // store range in pages_ary in ascending order int count = 0; for (count = *num_index; count <= (*num_index + num_end - num_begin); count++) { *(pages_ary + count) = num_begin++; *num_index += 1; } } else { // reverse order // make sure the upper bound does not exceed the number of pages if (num_begin > num_pages) { num_begin = num_pages; } // store range in pages_ary in descending order int count = 0; for (count = *num_index; count <= *num_index + num_begin - num_end; count++) { *(pages_ary + count) = num_begin--; *num_index += 1; } } succeeded = true; } else { LOGE("_order_pdf_pages(), ERROR: first and/or last numbers are not greater than " "%d: first num=%d, second num=%d", num_pages, num_begin, num_end); } } else { LOGE("_order_pdf_pages(), ERROR: first and/or last numbers are not greater than 0: " "first num=%d, second num=%d", num_begin, num_end); } } else { LOGE("_order_pdf_pages(), ERROR: first and/or last numbers are not numeric: first num=%s, " "second num=%s", num_begin_ary, num_end_ary); } return succeeded; } /* * Outputs page range of a pdf to page_range_str */ static void _get_pdf_page_range(JNIEnv *env, jobject javaJobParams, int *pages_ary, int num_pages, int *num_index, char *page_range_str) { char *page_range = NULL; jstring pageRangeObject = (jstring) (*env)->GetObjectField(env, javaJobParams, _LocalJobParamsField__page_range); if (pageRangeObject) { int page_range_size = (*env)->GetStringLength(env, pageRangeObject); const jbyte *pageRange = (jbyte *) (*env)->GetStringUTFChars(env, pageRangeObject, 0); if (strcmp((char *) pageRange, "") != 0) { page_range = (char *) malloc(page_range_size + 1); memset(page_range, 0, page_range_size + 1); strncpy(page_range, (char *) pageRange, page_range_size); // no empty strings if (strcmp(page_range, "") == 0) { free(page_range); page_range = NULL; } (*env)->ReleaseStringUTFChars(env, pageRangeObject, (const char *) pageRange); LOGD("_get_pdf_page_range(), page_range from JNI environment=%s", page_range); } } if (!page_range) { page_range = (char *) malloc(MAX_NUM_PAGES + 1); memset(page_range, 0, MAX_NUM_PAGES + 1); snprintf(page_range_str, MAX_NUM_PAGES, "1-%d", num_pages); snprintf(page_range, MAX_NUM_PAGES, "1-%d", num_pages); } else { strncpy(page_range_str, page_range, MAX_NUM_PAGES); } LOGD("_get_pdf_page_range(), range: %s, pages in document: %d", page_range_str, num_pages); // get the first token in page_range_str memset(pages_ary, 0, MAX_NUM_PAGES); char *page_range_split = strtok(page_range, ","); while (page_range_split != NULL) { if (!_order_pdf_pages(num_pages, pages_ary, num_index, page_range_split)) { snprintf(page_range_str, MAX_NUM_PAGES, "1-%d", num_pages); LOGD("_get_pdf_page_range(), setting page_range to: %s", page_range_str); _order_pdf_pages(num_pages, pages_ary, num_index, page_range_str); break; } // get next range token page_range_split = strtok(NULL, ","); } if (page_range) { free(page_range); } } /* * Sends a pdf to a printer */ static jint _print_pdf_pages(wJob_t job_handle, printer_capabilities_t *printer_cap, duplex_t duplex, char *pathname, int num_index, int *pages_ary) { int num_pages = num_index; // now, print the pages int page_index; jint result = ERROR; // print forward direction if printer prints pages face down; otherwise print backward // NOTE: last page is sent from calling function if (printer_cap->faceDownTray || duplex) { LOGD("_print_pdf_pages(), pages print face down or duplex, printing in normal order"); page_index = 0; while (page_index < num_pages) { LOGD("_print_pdf_pages(), PRINTING PDF: %d", *(pages_ary + page_index)); result = wprintPage(job_handle, *(pages_ary + page_index++), pathname, false, true, 0, 0, 0, 0); if (result != OK) { break; } } } else { LOGI(" _print_pdf_pages(), pages print face up, printing in reverse"); page_index = num_pages - 1; while (page_index >= 0) { LOGD("_print_pdf_pages(), PRINTING PDF: %s, page: %d", pathname, *(pages_ary + page_index)); result = wprintPage(job_handle, *(pages_ary + page_index--), pathname, false, true, 0, 0, 0, 0); if (result != OK) { break; } } } LOGI(" _print_pdf_pages(), printing result: %s", result == OK ? "OK" : "ERROR"); return result; } /* * Initialize JNI. Maps java values to jni values. */ static void _initJNI(JNIEnv *env, jobject callbackReceiver, jstring fakeDir) { _fakeDir = (jstring) (*env)->NewGlobalRef(env, fakeDir); // fill out static accessors for wPrintJobParameters _LocalJobParamsClass = (jclass) (*env)->NewGlobalRef( env, (*env)->FindClass(env, "com/android/bips/jni/LocalJobParams")); _LocalJobParamsField__borderless = (*env)->GetFieldID(env, _LocalJobParamsClass, "borderless", "I"); _LocalJobParamsField__duplex = (*env)->GetFieldID(env, _LocalJobParamsClass, "duplex", "I"); _LocalJobParamsField__media_size = (*env)->GetFieldID(env, _LocalJobParamsClass, "media_size", "I"); _LocalJobParamsField__media_type = (*env)->GetFieldID(env, _LocalJobParamsClass, "media_type", "I"); _LocalJobParamsField__media_tray = (*env)->GetFieldID(env, _LocalJobParamsClass, "media_tray", "I"); _LocalJobParamsField__color_space = (*env)->GetFieldID(env, _LocalJobParamsClass, "color_space", "I"); _LocalJobParamsField__render_flags = (*env)->GetFieldID(env, _LocalJobParamsClass, "render_flags", "I"); _LocalJobParamsField__num_copies = (*env)->GetFieldID(env, _LocalJobParamsClass, "num_copies", "I"); _LocalJobParamsField__page_range = (*env)->GetFieldID(env, _LocalJobParamsClass, "page_range", "Ljava/lang/String;"); _LocalJobParamsField__print_resolution = (*env)->GetFieldID(env, _LocalJobParamsClass, "print_resolution", "I"); _LocalJobParamsField__printable_width = (*env)->GetFieldID(env, _LocalJobParamsClass, "printable_width", "I"); _LocalJobParamsField__printable_height = (*env)->GetFieldID(env, _LocalJobParamsClass, "printable_height", "I"); _LocalJobParamsField__page_width = (*env)->GetFieldID(env, _LocalJobParamsClass, "page_width", "F"); _LocalJobParamsField__page_height = (*env)->GetFieldID(env, _LocalJobParamsClass, "page_height", "F"); _LocalJobParamsField__page_margin_top = (*env)->GetFieldID(env, _LocalJobParamsClass, "page_margin_top", "F"); _LocalJobParamsField__page_margin_left = (*env)->GetFieldID(env, _LocalJobParamsClass, "page_margin_left", "F"); _LocalJobParamsField__page_margin_right = (*env)->GetFieldID(env, _LocalJobParamsClass, "page_margin_right", "F"); _LocalJobParamsField__page_margin_bottom = (*env)->GetFieldID(env, _LocalJobParamsClass, "page_margin_bottom", "F"); _LocalJobParamsField__nativeData = (*env)->GetFieldID(env, _LocalJobParamsClass, "nativeData", "[B"); _LocalJobParamsField__fit_to_page = (*env)->GetFieldID(env, _LocalJobParamsClass, "fit_to_page", "Z"); _LocalJobParamsField__fill_page = (*env)->GetFieldID(env, _LocalJobParamsClass, "fill_page", "Z"); _LocalJobParamsField__auto_rotate = (*env)->GetFieldID(env, _LocalJobParamsClass, "auto_rotate", "Z"); _LocalJobParamsField__portrait_mode = (*env)->GetFieldID(env, _LocalJobParamsClass, "portrait_mode", "Z"); _LocalJobParamsField__landscape_mode = (*env)->GetFieldID(env, _LocalJobParamsClass, "landscape_mode", "Z"); _LocalJobParamsField__document_category = (*env)->GetFieldID(env, _LocalJobParamsClass, "document_category", "Ljava/lang/String;"); _LocalJobParamsField__alignment = (*env)->GetFieldID(env, _LocalJobParamsClass, "alignment", "I"); _LocalJobParamsField__job_margin_top = (*env)->GetFieldID(env, _LocalJobParamsClass, "job_margin_top", "F"); _LocalJobParamsField__job_margin_left = (*env)->GetFieldID(env, _LocalJobParamsClass, "job_margin_left", "F"); _LocalJobParamsField__job_margin_right = (*env)->GetFieldID(env, _LocalJobParamsClass, "job_margin_right", "F"); _LocalJobParamsField__job_margin_bottom = (*env)->GetFieldID(env, _LocalJobParamsClass, "job_margin_bottom", "F"); _LocalJobParamsField__document_scaling = (*env)->GetFieldID(env, _LocalJobParamsClass, "document_scaling", "Z"); _LocalJobParamsField__job_name = (*env)->GetFieldID(env, _LocalJobParamsClass, "job_name", "Ljava/lang/String;"); _LocalJobParamsField__job_originating_user_name = (*env)->GetFieldID( env, _LocalJobParamsClass, "job_originating_user_name", "Ljava/lang/String;"); _LocalJobParamsField__pdf_render_resolution = (*env)->GetFieldID(env, _LocalJobParamsClass, "pdf_render_resolution", "I"); // fill out static accessors for LocalPrinterCapabilities _LocalPrinterCapabilitiesClass = (jclass) (*env)->NewGlobalRef(env, (*env)->FindClass( env, "com/android/bips/jni/LocalPrinterCapabilities")); _LocalPrinterCapabilitiesField__path = (*env)->GetFieldID( env, _LocalPrinterCapabilitiesClass, "path", "Ljava/lang/String;"); _LocalPrinterCapabilitiesField__name = (*env)->GetFieldID( env, _LocalPrinterCapabilitiesClass, "name", "Ljava/lang/String;"); _LocalPrinterCapabilitiesField__uuid = (*env)->GetFieldID( env, _LocalPrinterCapabilitiesClass, "uuid", "Ljava/lang/String;"); _LocalPrinterCapabilitiesField__location = (*env)->GetFieldID( env, _LocalPrinterCapabilitiesClass, "location", "Ljava/lang/String;"); _LocalPrinterCapabilitiesField__duplex = (*env)->GetFieldID( env, _LocalPrinterCapabilitiesClass, "duplex", "Z"); _LocalPrinterCapabilitiesField__borderless = (*env)->GetFieldID( env, _LocalPrinterCapabilitiesClass, "borderless", "Z"); _LocalPrinterCapabilitiesField__color = (*env)->GetFieldID( env, _LocalPrinterCapabilitiesClass, "color", "Z"); _LocalPrinterCapabilitiesField__isSupported = (*env)->GetFieldID( env, _LocalPrinterCapabilitiesClass, "isSupported", "Z"); _LocalPrinterCapabilitiesField__mediaDefault = (*env)->GetFieldID( env, _LocalPrinterCapabilitiesClass, "mediaDefault", "Ljava/lang/String;"); _LocalPrinterCapabilitiesField__supportedMediaTypes = (*env)->GetFieldID( env, _LocalPrinterCapabilitiesClass, "supportedMediaTypes", "[I"); _LocalPrinterCapabilitiesField__supportedMediaSizes = (*env)->GetFieldID( env, _LocalPrinterCapabilitiesClass, "supportedMediaSizes", "[I"); _LocalPrinterCapabilitiesField__nativeData = (*env)->GetFieldID( env, _LocalPrinterCapabilitiesClass, "nativeData", "[B"); _LocalPrinterCapabilitiesField__certificate = (*env)->GetFieldID( env, _LocalPrinterCapabilitiesClass, "certificate", "[B"); _JobCallbackParamsClass = (jclass) (*env)->NewGlobalRef(env, (*env)->FindClass( env, "com/android/bips/jni/JobCallbackParams")); _JobCallbackParamsMethod__init = (*env)->GetMethodID(env, _JobCallbackParamsClass, "", "()V"); _JobCallbackParamsField__jobId = (*env)->GetFieldID(env, _JobCallbackParamsClass, "jobId", "I"); _JobCallbackParamsField__jobState = (*env)->GetFieldID( env, _JobCallbackParamsClass, "jobState", "Ljava/lang/String;"); _JobCallbackParamsField__jobDoneResult = (*env)->GetFieldID( env, _JobCallbackParamsClass, "jobDoneResult", "Ljava/lang/String;"); _JobCallbackParamsField__blockedReasons = (*env)->GetFieldID( env, _JobCallbackParamsClass, "blockedReasons", "[Ljava/lang/String;"); _JobCallbackParamsField__certificate = (*env)->GetFieldID( env, _JobCallbackParamsClass, "certificate", "[B"); if (callbackReceiver) { _callbackReceiver = (jobject) (*env)->NewGlobalRef(env, callbackReceiver); } if (_callbackReceiver) { _JobCallbackClass = (jclass) (*env)->NewGlobalRef(env, (*env)->GetObjectClass( env, _callbackReceiver)); _JobCallbackMethod__jobCallback = (*env)->GetMethodID( env, _JobCallbackClass, "jobCallback", "(ILcom/android/bips/jni/JobCallbackParams;)V"); } else { _callbackReceiver = 0; } _PrintServiceStringsClass = (jclass) (*env)->NewGlobalRef(env, (*env)->FindClass( env, "com/android/bips/jni/BackendConstants")); _PrintServiceStringsField__JOB_STATE_QUEUED = (*env)->GetStaticFieldID( env, _PrintServiceStringsClass, "JOB_STATE_QUEUED", "Ljava/lang/String;"); _PrintServiceStringsField__JOB_STATE_RUNNING = (*env)->GetStaticFieldID( env, _PrintServiceStringsClass, "JOB_STATE_RUNNING", "Ljava/lang/String;"); _PrintServiceStringsField__JOB_STATE_BLOCKED = (*env)->GetStaticFieldID( env, _PrintServiceStringsClass, "JOB_STATE_BLOCKED", "Ljava/lang/String;"); _PrintServiceStringsField__JOB_STATE_DONE = (*env)->GetStaticFieldID( env, _PrintServiceStringsClass, "JOB_STATE_DONE", "Ljava/lang/String;"); _PrintServiceStringsField__JOB_STATE_OTHER = (*env)->GetStaticFieldID( env, _PrintServiceStringsClass, "JOB_STATE_OTHER", "Ljava/lang/String;"); _PrintServiceStringsField__JOB_DONE_OK = (*env)->GetStaticFieldID( env, _PrintServiceStringsClass, "JOB_DONE_OK", "Ljava/lang/String;"); _PrintServiceStringsField__JOB_DONE_ERROR = (*env)->GetStaticFieldID( env, _PrintServiceStringsClass, "JOB_DONE_ERROR", "Ljava/lang/String;"); _PrintServiceStringsField__JOB_DONE_CANCELLED = (*env)->GetStaticFieldID( env, _PrintServiceStringsClass, "JOB_DONE_CANCELLED", "Ljava/lang/String;"); _PrintServiceStringsField__JOB_DONE_CORRUPT = (*env)->GetStaticFieldID( env, _PrintServiceStringsClass, "JOB_DONE_CORRUPT", "Ljava/lang/String;"); _PrintServiceStringsField__JOB_DONE_OTHER = (*env)->GetStaticFieldID( env, _PrintServiceStringsClass, "JOB_DONE_OTHER", "Ljava/lang/String;"); _PrintServiceStringsField__BLOCKED_REASON__OFFLINE = (*env)->GetStaticFieldID( env, _PrintServiceStringsClass, "BLOCKED_REASON__OFFLINE", "Ljava/lang/String;"); _PrintServiceStringsField__BLOCKED_REASON__BUSY = (*env)->GetStaticFieldID( env, _PrintServiceStringsClass, "BLOCKED_REASON__BUSY", "Ljava/lang/String;"); _PrintServiceStringsField__BLOCKED_REASON__CANCELLED = (*env)->GetStaticFieldID( env, _PrintServiceStringsClass, "BLOCKED_REASON__CANCELLED", "Ljava/lang/String;"); _PrintServiceStringsField__BLOCKED_REASON__OUT_OF_PAPER = (*env)->GetStaticFieldID( env, _PrintServiceStringsClass, "BLOCKED_REASON__OUT_OF_PAPER", "Ljava/lang/String;"); _PrintServiceStringsField__BLOCKED_REASON__OUT_OF_INK = (*env)->GetStaticFieldID( env, _PrintServiceStringsClass, "BLOCKED_REASON__OUT_OF_INK", "Ljava/lang/String;"); _PrintServiceStringsField__BLOCKED_REASON__OUT_OF_TONER = (*env)->GetStaticFieldID( env, _PrintServiceStringsClass, "BLOCKED_REASON__OUT_OF_TONER", "Ljava/lang/String;"); _PrintServiceStringsField__BLOCKED_REASON__JAMMED = (*env)->GetStaticFieldID( env, _PrintServiceStringsClass, "BLOCKED_REASON__JAMMED", "Ljava/lang/String;"); _PrintServiceStringsField__BLOCKED_REASON__DOOR_OPEN = (*env)->GetStaticFieldID( env, _PrintServiceStringsClass, "BLOCKED_REASON__DOOR_OPEN", "Ljava/lang/String;"); _PrintServiceStringsField__BLOCKED_REASON__SERVICE_REQUEST = (*env)->GetStaticFieldID( env, _PrintServiceStringsClass, "BLOCKED_REASON__SERVICE_REQUEST", "Ljava/lang/String;"); _PrintServiceStringsField__BLOCKED_REASON__LOW_ON_INK = (*env)->GetStaticFieldID( env, _PrintServiceStringsClass, "BLOCKED_REASON__LOW_ON_INK", "Ljava/lang/String;"); _PrintServiceStringsField__BLOCKED_REASON__LOW_ON_TONER = (*env)->GetStaticFieldID( env, _PrintServiceStringsClass, "BLOCKED_REASON__LOW_ON_TONER", "Ljava/lang/String;"); _PrintServiceStringsField__BLOCKED_REASON__REALLY_LOW_ON_INK = (*env)->GetStaticFieldID( env, _PrintServiceStringsClass, "BLOCKED_REASON__REALLY_LOW_ON_INK", "Ljava/lang/String;"); _PrintServiceStringsField__BLOCKED_REASON__BAD_CERTIFICATE = (*env)->GetStaticFieldID( env, _PrintServiceStringsClass, "BLOCKED_REASON__BAD_CERTIFICATE", "Ljava/lang/String;"); _PrintServiceStringsField__BLOCKED_REASON__UNKNOWN = (*env)->GetStaticFieldID( env, _PrintServiceStringsClass, "BLOCKED_REASON__UNKNOWN", "Ljava/lang/String;"); _PrintServiceStringsField__ALIGNMENT__CENTER = (*env)->GetStaticFieldID( env, _PrintServiceStringsClass, "ALIGN_CENTER", "I"); _PrintServiceStringsField__ALIGNMENT__CENTER_HORIZONTAL = (*env)->GetStaticFieldID( env, _PrintServiceStringsClass, "ALIGN_CENTER_HORIZONTAL", "I"); _PrintServiceStringsField__ALIGNMENT__CENTER_VERTICAL = (*env)->GetStaticFieldID( env, _PrintServiceStringsClass, "ALIGN_CENTER_VERTICIAL", "I"); _PrintServiceStringsField__ALIGNMENT__CENTER_HORIZONTAL_ON_ORIENTATION = (*env)->GetStaticFieldID(env, _PrintServiceStringsClass, "ALIGN_CENTER_HORIZONTAL_ON_ORIENTATION", "I"); pdf_render_init(env); } /* * Converts java printer caps to c and saves them to wprintPrinterCaps */ static int _convertPrinterCaps_to_C(JNIEnv *env, jobject javaPrinterCaps, printer_capabilities_t *wprintPrinterCaps) { if (!javaPrinterCaps || !wprintPrinterCaps) { return ERROR; } jbyteArray nativeDataObject = (jbyteArray) (*env)->GetObjectField( env, javaPrinterCaps, _LocalPrinterCapabilitiesField__nativeData); if (!nativeDataObject) { return ERROR; } jbyte *nativeDataPtr = (*env)->GetByteArrayElements(env, nativeDataObject, NULL); memcpy(wprintPrinterCaps, (const void *) nativeDataPtr, sizeof(printer_capabilities_t)); (*env)->ReleaseByteArrayElements(env, nativeDataObject, nativeDataPtr, 0); return OK; } /* * Converts printer caps to java and saves them to javaPrinterCaps */ static int _convertPrinterCaps_to_Java(JNIEnv *env, jobject javaPrinterCaps, const printer_capabilities_t *wprintPrinterCaps) { if (!javaPrinterCaps || !wprintPrinterCaps) { return ERROR; } int arrayCreated = 0; jbyteArray nativeDataObject = (jbyteArray) (*env)->GetObjectField( env, javaPrinterCaps, _LocalPrinterCapabilitiesField__nativeData); if (!nativeDataObject) { arrayCreated = 1; nativeDataObject = (*env)->NewByteArray(env, sizeof(printer_capabilities_t)); } jbyte *nativeDataPtr = (*env)->GetByteArrayElements(env, nativeDataObject, NULL); memcpy((void *) nativeDataPtr, wprintPrinterCaps, sizeof(printer_capabilities_t)); (*env)->ReleaseByteArrayElements(env, nativeDataObject, nativeDataPtr, 0); if (arrayCreated) { (*env)->SetObjectField(env, javaPrinterCaps, _LocalPrinterCapabilitiesField__nativeData, nativeDataObject); (*env)->DeleteLocalRef(env, nativeDataObject); } (*env)->SetBooleanField(env, javaPrinterCaps, _LocalPrinterCapabilitiesField__duplex, (jboolean) wprintPrinterCaps->duplex); (*env)->SetBooleanField(env, javaPrinterCaps, _LocalPrinterCapabilitiesField__borderless, (jboolean) wprintPrinterCaps->borderless); (*env)->SetBooleanField(env, javaPrinterCaps, _LocalPrinterCapabilitiesField__color, (jboolean) wprintPrinterCaps->color); (*env)->SetBooleanField(env, javaPrinterCaps, _LocalPrinterCapabilitiesField__isSupported, (jboolean) wprintPrinterCaps->isSupported); stringToJava(env, javaPrinterCaps, _LocalPrinterCapabilitiesField__mediaDefault, wprintPrinterCaps->mediaDefault); stringToJava(env, javaPrinterCaps, _LocalPrinterCapabilitiesField__path, wprintPrinterCaps->printerUri); stringToJava(env, javaPrinterCaps, _LocalPrinterCapabilitiesField__name, wprintPrinterCaps->name); stringToJava(env, javaPrinterCaps, _LocalPrinterCapabilitiesField__uuid, wprintPrinterCaps->uuid); stringToJava(env, javaPrinterCaps, _LocalPrinterCapabilitiesField__location, wprintPrinterCaps->location); jintArray intArray; int *intArrayPtr; int index; intArray = (*env)->NewIntArray(env, wprintPrinterCaps->numSupportedMediaTypes); intArrayPtr = (*env)->GetIntArrayElements(env, intArray, NULL); for (index = 0; index < wprintPrinterCaps->numSupportedMediaTypes; index++) { intArrayPtr[index] = (int) wprintPrinterCaps->supportedMediaTypes[index]; } (*env)->ReleaseIntArrayElements(env, intArray, intArrayPtr, 0); (*env)->SetObjectField(env, javaPrinterCaps, _LocalPrinterCapabilitiesField__supportedMediaTypes, intArray); (*env)->DeleteLocalRef(env, intArray); intArray = (*env)->NewIntArray(env, wprintPrinterCaps->numSupportedMediaSizes); intArrayPtr = (*env)->GetIntArrayElements(env, intArray, NULL); for (index = 0; index < wprintPrinterCaps->numSupportedMediaSizes; index++) { intArrayPtr[index] = (int) wprintPrinterCaps->supportedMediaSizes[index]; } (*env)->ReleaseIntArrayElements(env, intArray, intArrayPtr, 0); (*env)->SetObjectField(env, javaPrinterCaps, _LocalPrinterCapabilitiesField__supportedMediaSizes, intArray); (*env)->DeleteLocalRef(env, intArray); int count; for (count = index = 0; index < (sizeof(int) * 8); index++) { if ((wprintPrinterCaps->supportedInputMimeTypes & (1 << index)) != 0) { count++; } } return OK; } /* * Converts str to a java string */ static void stringToJava(JNIEnv *env, jobject obj, jfieldID id, const char *str) { jstring jStr; // If null, copy an empty string if (!str) str = ""; jStr = (*env)->NewStringUTF(env, str); (*env)->SetObjectField(env, obj, id, jStr); (*env)->DeleteLocalRef(env, jStr); } /* * Converts javaJobParams to C and saves them to wprintJobParams */ static int _convertJobParams_to_C(JNIEnv *env, jobject javaJobParams, wprint_job_params_t *wprintJobParams) { if (!javaJobParams || !wprintJobParams) { return ERROR; } jbyteArray nativeDataObject = (jbyteArray) (*env)->GetObjectField( env, javaJobParams, _LocalJobParamsField__nativeData); if (nativeDataObject == 0) { return ERROR; } jbyte *nativeDataPtr = (*env)->GetByteArrayElements(env, nativeDataObject, NULL); memcpy(wprintJobParams, (const void *) nativeDataPtr, sizeof(wprint_job_params_t)); (*env)->ReleaseByteArrayElements(env, nativeDataObject, nativeDataPtr, JNI_ABORT); wprintJobParams->media_size = (media_size_t) (*env)->GetIntField( env, javaJobParams, _LocalJobParamsField__media_size); wprintJobParams->media_type = (media_type_t) (*env)->GetIntField( env, javaJobParams, _LocalJobParamsField__media_type); wprintJobParams->duplex = (duplex_t) (*env)->GetIntField( env, javaJobParams, _LocalJobParamsField__duplex); wprintJobParams->color_space = (color_space_t) (*env)->GetIntField( env, javaJobParams, _LocalJobParamsField__color_space); wprintJobParams->media_tray = (media_tray_t) (*env)->GetIntField( env, javaJobParams, _LocalJobParamsField__media_tray); wprintJobParams->num_copies = (unsigned int) (*env)->GetIntField( env, javaJobParams, _LocalJobParamsField__num_copies); wprintJobParams->borderless = (bool) (*env)->GetIntField(env, javaJobParams, _LocalJobParamsField__borderless); wprintJobParams->render_flags = (unsigned int) (*env)->GetIntField( env, javaJobParams, _LocalJobParamsField__render_flags); wprintJobParams->pdf_render_resolution = (unsigned int) (*env)->GetIntField(env, javaJobParams, _LocalJobParamsField__pdf_render_resolution); // job margin setting wprintJobParams->job_top_margin = (float) (*env)->GetFloatField( env, javaJobParams, _LocalJobParamsField__job_margin_top); wprintJobParams->job_left_margin = (float) (*env)->GetFloatField( env, javaJobParams, _LocalJobParamsField__job_margin_left); wprintJobParams->job_right_margin = (float) (*env)->GetFloatField( env, javaJobParams, _LocalJobParamsField__job_margin_right); wprintJobParams->job_bottom_margin = (float) (*env)->GetFloatField( env, javaJobParams, _LocalJobParamsField__job_margin_bottom); if ((*env)->GetBooleanField(env, javaJobParams, _LocalJobParamsField__portrait_mode)) { wprintJobParams->render_flags |= RENDER_FLAG_PORTRAIT_MODE; } else if ((*env)->GetBooleanField(env, javaJobParams, _LocalJobParamsField__landscape_mode)) { wprintJobParams->render_flags |= RENDER_FLAG_LANDSCAPE_MODE; } else if ((*env)->GetBooleanField(env, javaJobParams, _LocalJobParamsField__auto_rotate)) { wprintJobParams->render_flags |= RENDER_FLAG_AUTO_ROTATE; } if ((*env)->GetBooleanField(env, javaJobParams, _LocalJobParamsField__fill_page)) { wprintJobParams->render_flags |= AUTO_SCALE_RENDER_FLAGS; } else if ((*env)->GetBooleanField(env, javaJobParams, _LocalJobParamsField__fit_to_page)) { wprintJobParams->render_flags |= AUTO_FIT_RENDER_FLAGS; if ((*env)->GetBooleanField(env, javaJobParams, _LocalJobParamsField__document_scaling)) { wprintJobParams->render_flags |= RENDER_FLAG_DOCUMENT_SCALING; } } int alignment = ((*env)->GetIntField(env, javaJobParams, _LocalJobParamsField__alignment)); if (alignment != 0) { wprintJobParams->render_flags &= ~(RENDER_FLAG_CENTER_VERTICAL | RENDER_FLAG_CENTER_HORIZONTAL | RENDER_FLAG_CENTER_ON_ORIENTATION); if (alignment & ((*env)->GetStaticIntField( env, _PrintServiceStringsClass, _PrintServiceStringsField__ALIGNMENT__CENTER_HORIZONTAL))) { wprintJobParams->render_flags |= RENDER_FLAG_CENTER_HORIZONTAL; } if (alignment & ((*env)->GetStaticIntField( env, _PrintServiceStringsClass, _PrintServiceStringsField__ALIGNMENT__CENTER_VERTICAL))) { wprintJobParams->render_flags |= RENDER_FLAG_CENTER_VERTICAL; } if (alignment & ((*env)->GetStaticIntField( env, _PrintServiceStringsClass, _PrintServiceStringsField__ALIGNMENT__CENTER_HORIZONTAL_ON_ORIENTATION))) { wprintJobParams->render_flags |= RENDER_FLAG_CENTER_ON_ORIENTATION; } if ((alignment & ((*env)->GetStaticIntField( env, _PrintServiceStringsClass, _PrintServiceStringsField__ALIGNMENT__CENTER))) == ((*env)->GetStaticIntField(env, _PrintServiceStringsClass, _PrintServiceStringsField__ALIGNMENT__CENTER))) { wprintJobParams->render_flags &= ~RENDER_FLAG_CENTER_ON_ORIENTATION; wprintJobParams->render_flags |= (RENDER_FLAG_CENTER_VERTICAL | RENDER_FLAG_CENTER_HORIZONTAL); } } jstring docCategory = (jstring) (*env)->GetObjectField(env, javaJobParams, _LocalJobParamsField__document_category); if (docCategory != NULL) { const char *category = (*env)->GetStringUTFChars(env, docCategory, NULL); if (category != NULL) { strncpy(wprintJobParams->docCategory, category, sizeof(wprintJobParams->docCategory) - 1); (*env)->ReleaseStringUTFChars(env, docCategory, category); } } // job name jstring jobName = (jstring) (*env)->GetObjectField(env, javaJobParams, _LocalJobParamsField__job_name); if (jobName != NULL) { const char *name = (*env)->GetStringUTFChars(env, jobName, NULL); if (name != NULL) { strncpy(wprintJobParams->job_name, name, sizeof(wprintJobParams->job_name) - 1); (*env)->ReleaseStringUTFChars(env, jobName, name); } } // job originating user name jstring jobOriginatingUserName = (jstring) (*env)->GetObjectField( env, javaJobParams, _LocalJobParamsField__job_originating_user_name); if (jobOriginatingUserName != NULL) { const char *name = (*env)->GetStringUTFChars(env, jobOriginatingUserName, NULL); if (name != NULL) { strncpy(wprintJobParams->job_originating_user_name, name, sizeof(wprintJobParams->job_originating_user_name) - 1); (*env)->ReleaseStringUTFChars(env, jobOriginatingUserName, name); } } free(wprintJobParams->page_range); wprintJobParams->page_range = NULL; jstring pageRangeObject = (jstring) (*env)->GetObjectField(env, javaJobParams, _LocalJobParamsField__page_range); if (pageRangeObject) { int page_range_size = (*env)->GetStringLength(env, pageRangeObject); const jbyte *pageRange = (jbyte *) (*env)->GetStringUTFChars(env, pageRangeObject, 0); if (strcmp((char *) pageRange, "") != 0) { wprintJobParams->page_range = (char *) malloc(page_range_size + 1); memset(wprintJobParams->page_range, 0, page_range_size + 1); strncpy(wprintJobParams->page_range, (char *) pageRange, page_range_size); (*env)->ReleaseStringUTFChars(env, pageRangeObject, (const char *) pageRange); } } return OK; } /* * Converts wprintJobParams to java and saves them to javaJobParams */ static int _covertJobParams_to_Java(JNIEnv *env, jobject javaJobParams, wprint_job_params_t *wprintJobParams) { if (!javaJobParams || !wprintJobParams) { return ERROR; } jbyteArray nativeDataObject = (jbyteArray) (*env)->GetObjectField( env, javaJobParams, _LocalJobParamsField__nativeData); if (!nativeDataObject) { nativeDataObject = (*env)->NewByteArray(env, sizeof(wprint_job_params_t)); (*env)->SetObjectField(env, javaJobParams, _LocalJobParamsField__nativeData, nativeDataObject); nativeDataObject = (jbyteArray) (*env)->GetObjectField(env, javaJobParams, _LocalJobParamsField__nativeData); } jbyte *nativeDataPtr = (*env)->GetByteArrayElements(env, nativeDataObject, NULL); memcpy((void *) nativeDataPtr, wprintJobParams, sizeof(wprint_job_params_t)); (*env)->ReleaseByteArrayElements(env, nativeDataObject, nativeDataPtr, 0); // update job parameters (*env)->SetIntField(env, javaJobParams, _LocalJobParamsField__media_size, (int) wprintJobParams->media_size); (*env)->SetIntField(env, javaJobParams, _LocalJobParamsField__media_type, (int) wprintJobParams->media_type); (*env)->SetIntField(env, javaJobParams, _LocalJobParamsField__duplex, (int) wprintJobParams->duplex); (*env)->SetIntField(env, javaJobParams, _LocalJobParamsField__color_space, (int) wprintJobParams->color_space); (*env)->SetIntField(env, javaJobParams, _LocalJobParamsField__media_tray, (int) wprintJobParams->media_tray); (*env)->SetIntField(env, javaJobParams, _LocalJobParamsField__num_copies, (int) wprintJobParams->num_copies); (*env)->SetIntField(env, javaJobParams, _LocalJobParamsField__borderless, (int) wprintJobParams->borderless); (*env)->SetIntField(env, javaJobParams, _LocalJobParamsField__render_flags, (int) wprintJobParams->render_flags); (*env)->SetIntField(env, javaJobParams, _LocalJobParamsField__pdf_render_resolution, wprintJobParams->pdf_render_resolution); (*env)->SetBooleanField(env, javaJobParams, _LocalJobParamsField__fit_to_page, (jboolean) ((wprintJobParams->render_flags & AUTO_FIT_RENDER_FLAGS) == AUTO_FIT_RENDER_FLAGS)); (*env)->SetBooleanField(env, javaJobParams, _LocalJobParamsField__fill_page, (jboolean) ((wprintJobParams->render_flags & AUTO_SCALE_RENDER_FLAGS) == AUTO_SCALE_RENDER_FLAGS)); (*env)->SetBooleanField(env, javaJobParams, _LocalJobParamsField__auto_rotate, (jboolean) ((wprintJobParams->render_flags & RENDER_FLAG_AUTO_ROTATE) != 0)); (*env)->SetBooleanField(env, javaJobParams, _LocalJobParamsField__portrait_mode, (jboolean) ( (wprintJobParams->render_flags & RENDER_FLAG_PORTRAIT_MODE) != 0)); (*env)->SetBooleanField(env, javaJobParams, _LocalJobParamsField__landscape_mode, (jboolean) ( (wprintJobParams->render_flags & RENDER_FLAG_LANDSCAPE_MODE) != 0)); // update the printable area & DPI information (*env)->SetIntField(env, javaJobParams, _LocalJobParamsField__print_resolution, (int) wprintJobParams->pixel_units); (*env)->SetIntField(env, javaJobParams, _LocalJobParamsField__printable_width, (int) wprintJobParams->width); (*env)->SetIntField(env, javaJobParams, _LocalJobParamsField__printable_height, (int) wprintJobParams->height); // update the page size information (*env)->SetFloatField(env, javaJobParams, _LocalJobParamsField__page_width, wprintJobParams->page_width); (*env)->SetFloatField(env, javaJobParams, _LocalJobParamsField__page_height, wprintJobParams->page_height); (*env)->SetFloatField(env, javaJobParams, _LocalJobParamsField__page_margin_top, wprintJobParams->page_top_margin); (*env)->SetFloatField(env, javaJobParams, _LocalJobParamsField__page_margin_left, wprintJobParams->page_left_margin); (*env)->SetFloatField(env, javaJobParams, _LocalJobParamsField__page_margin_right, wprintJobParams->page_right_margin); (*env)->SetFloatField(env, javaJobParams, _LocalJobParamsField__page_margin_bottom, wprintJobParams->page_bottom_margin); (*env)->SetFloatField(env, javaJobParams, _LocalJobParamsField__job_margin_top, wprintJobParams->job_top_margin); (*env)->SetFloatField(env, javaJobParams, _LocalJobParamsField__job_margin_left, wprintJobParams->job_left_margin); (*env)->SetFloatField(env, javaJobParams, _LocalJobParamsField__job_margin_right, wprintJobParams->job_right_margin); (*env)->SetFloatField(env, javaJobParams, _LocalJobParamsField__job_margin_bottom, wprintJobParams->job_bottom_margin); return OK; } /* * Handles print job callbacks. Handles job states and blocked reasons */ static void _wprint_callback_fn(wJob_t job_handle, void *param) { jstring jStr; wprint_job_callback_params_t *cb_param = (wprint_job_callback_params_t *) param; if (!cb_param) { return; } int needDetach = 0; JNIEnv *env; if ((*_JVM)->GetEnv(_JVM, (void **) &env, JNI_VERSION_1_6) < 0) { needDetach = 1; if ((*_JVM)->AttachCurrentThread(_JVM, &env, NULL) < 0) { return; } } jobject callbackParams = (*env)->NewObject(env, _JobCallbackParamsClass, _JobCallbackParamsMethod__init); if (callbackParams != 0) { switch (cb_param->state) { case JOB_QUEUED: jStr = (jstring) (*env)->GetStaticObjectField( env, _PrintServiceStringsClass, _PrintServiceStringsField__JOB_STATE_QUEUED); break; case JOB_RUNNING: jStr = (jstring) (*env)->GetStaticObjectField( env, _PrintServiceStringsClass, _PrintServiceStringsField__JOB_STATE_RUNNING); break; case JOB_BLOCKED: jStr = (jstring) (*env)->GetStaticObjectField( env, _PrintServiceStringsClass, _PrintServiceStringsField__JOB_STATE_BLOCKED); break; case JOB_DONE: jStr = (jstring) (*env)->GetStaticObjectField( env, _PrintServiceStringsClass, _PrintServiceStringsField__JOB_STATE_DONE); break; default: jStr = (jstring) (*env)->GetStaticObjectField( env, _PrintServiceStringsClass, _PrintServiceStringsField__JOB_STATE_OTHER); break; } (*env)->SetObjectField(env, callbackParams, _JobCallbackParamsField__jobState, jStr); if (cb_param->state == JOB_DONE) { switch (cb_param->job_done_result) { case OK: jStr = (jstring) (*env)->GetStaticObjectField( env, _PrintServiceStringsClass, _PrintServiceStringsField__JOB_DONE_OK); break; case ERROR: jStr = (jstring) (*env)->GetStaticObjectField( env, _PrintServiceStringsClass, _PrintServiceStringsField__JOB_DONE_ERROR); break; case CANCELLED: jStr = (jstring) (*env)->GetStaticObjectField( env, _PrintServiceStringsClass, _PrintServiceStringsField__JOB_DONE_CANCELLED); break; case CORRUPT: jStr = (jstring) (*env)->GetStaticObjectField( env, _PrintServiceStringsClass, _PrintServiceStringsField__JOB_DONE_CORRUPT); break; default: jStr = (jstring) (*env)->GetStaticObjectField( env, _PrintServiceStringsClass, _PrintServiceStringsField__JOB_DONE_OTHER); break; } (*env)->SetObjectField(env, callbackParams, _JobCallbackParamsField__jobDoneResult, jStr); } int i, count; for (count = i = 0; i < PRINT_STATUS_MAX_STATE; i++) { if (cb_param->blocked_reasons & (1 << i)) { count++; } } if (count > 0) { jStr = (*env)->NewStringUTF(env, ""); jobjectArray stringArray = (*env)->NewObjectArray(env, count, (*env)->FindClass( env, "java/lang/String"), jStr); (*env)->DeleteLocalRef(env, jStr); unsigned int blocked_reasons = cb_param->blocked_reasons; for (count = i = 0; i < PRINT_STATUS_MAX_STATE; i++) { jStr = NULL; if ((blocked_reasons & (1 << i)) == 0) { jStr = NULL; } else if (blocked_reasons & BLOCKED_REASON_UNABLE_TO_CONNECT) { jStr = (jstring) (*env)->GetStaticObjectField( env, _PrintServiceStringsClass, _PrintServiceStringsField__BLOCKED_REASON__OFFLINE); } else if (blocked_reasons & BLOCKED_REASON_BUSY) { jStr = (jstring) (*env)->GetStaticObjectField( env, _PrintServiceStringsClass, _PrintServiceStringsField__BLOCKED_REASON__BUSY); } else if (blocked_reasons & BLOCKED_REASONS_CANCELLED) { jStr = (jstring) (*env)->GetStaticObjectField( env, _PrintServiceStringsClass, _PrintServiceStringsField__BLOCKED_REASON__CANCELLED); } else if (blocked_reasons & BLOCKED_REASON_JAMMED) { jStr = (jstring) (*env)->GetStaticObjectField( env, _PrintServiceStringsClass, _PrintServiceStringsField__BLOCKED_REASON__JAMMED); } else if (blocked_reasons & BLOCKED_REASON_OUT_OF_PAPER) { jStr = (jstring) (*env)->GetStaticObjectField( env, _PrintServiceStringsClass, _PrintServiceStringsField__BLOCKED_REASON__OUT_OF_PAPER); } else if (blocked_reasons & BLOCKED_REASON_OUT_OF_INK) { jStr = (jstring) (*env)->GetStaticObjectField( env, _PrintServiceStringsClass, _PrintServiceStringsField__BLOCKED_REASON__OUT_OF_INK); } else if (blocked_reasons & BLOCKED_REASON_OUT_OF_TONER) { jStr = (jstring) (*env)->GetStaticObjectField( env, _PrintServiceStringsClass, _PrintServiceStringsField__BLOCKED_REASON__OUT_OF_TONER); } else if (blocked_reasons & BLOCKED_REASON_DOOR_OPEN) { jStr = (jstring) (*env)->GetStaticObjectField( env, _PrintServiceStringsClass, _PrintServiceStringsField__BLOCKED_REASON__DOOR_OPEN); } else if (blocked_reasons & BLOCKED_REASON_SVC_REQUEST) { jStr = (jstring) (*env)->GetStaticObjectField( env, _PrintServiceStringsClass, _PrintServiceStringsField__BLOCKED_REASON__SERVICE_REQUEST); } else if (blocked_reasons & BLOCKED_REASON_LOW_ON_INK) { jStr = (jstring) (*env)->GetStaticObjectField( env, _PrintServiceStringsClass, _PrintServiceStringsField__BLOCKED_REASON__LOW_ON_INK); } else if (blocked_reasons & BLOCKED_REASON_LOW_ON_TONER) { jStr = (jstring) (*env)->GetStaticObjectField( env, _PrintServiceStringsClass, _PrintServiceStringsField__BLOCKED_REASON__LOW_ON_TONER); } else if (blocked_reasons & BLOCKED_REASON_PRINT_STATUS_VERY_LOW_ON_INK) { jStr = (jstring) (*env)->GetStaticObjectField( env, _PrintServiceStringsClass, _PrintServiceStringsField__BLOCKED_REASON__REALLY_LOW_ON_INK); } else if (blocked_reasons & BLOCKED_REASON_BAD_CERTIFICATE) { jStr = (jstring) (*env)->GetStaticObjectField( env, _PrintServiceStringsClass, _PrintServiceStringsField__BLOCKED_REASON__BAD_CERTIFICATE); } else if (blocked_reasons & BLOCKED_REASON_UNKNOWN) { jStr = (jstring) (*env)->GetStaticObjectField( env, _PrintServiceStringsClass, _PrintServiceStringsField__BLOCKED_REASON__UNKNOWN); } blocked_reasons &= ~(1 << i); if (jStr != 0) { (*env)->SetObjectArrayElement(env, stringArray, count++, jStr); } } (*env)->SetObjectField(env, callbackParams, _JobCallbackParamsField__blockedReasons, stringArray); } (*env)->SetIntField(env, callbackParams, _JobCallbackParamsField__jobId, (jint) job_handle); if (cb_param->certificate) { LOGI("_wprint_callback_fn: copying certificate len=%d", cb_param->certificate_len); jbyteArray certificate = (*env)->NewByteArray(env, cb_param->certificate_len); jbyte *certificateBytes = (*env)->GetByteArrayElements(env, certificate, 0); memcpy(certificateBytes, (const void *) cb_param->certificate, cb_param->certificate_len); (*env)->ReleaseByteArrayElements(env, certificate, certificateBytes, 0); (*env)->SetObjectField(env, callbackParams, _JobCallbackParamsField__certificate, certificate); (*env)->DeleteLocalRef(env, certificate); } else { LOGI("_wprint_callback_fn: there is no certificate"); // No cert, set NULL (*env)->SetObjectField(env, callbackParams, _JobCallbackParamsField__certificate, NULL); } (*env)->CallVoidMethod(env, _callbackReceiver, _JobCallbackMethod__jobCallback, (jint) job_handle, callbackParams); (*env)->DeleteLocalRef(env, callbackParams); } if (needDetach) { (*_JVM)->DetachCurrentThread(_JVM); } } /* * Initialize wprint JNI */ JNIEXPORT jint JNICALL Java_com_android_bips_ipp_Backend_nativeInit( JNIEnv *env, jobject obj, jobject callbackReceiver, jstring fakeDir, jint apiVersion) { LOGI("nativeInit JNIenv is %p", env); int result; // Setup the global JavaVM reference first. (*env)->GetJavaVM(env, &_JVM); // Initialize the Android API version value g_API_version = apiVersion; _initJNI(env, callbackReceiver, fakeDir); // initialize wprint library result = wprintInit(); // return the result return result; } /* * Copies a given string and returns the copy */ static char *copyToNewString(JNIEnv *env, jstring source) { const char *fromJava; char *newString; fromJava = (*env)->GetStringUTFChars(env, source, NULL); if (fromJava == NULL) return NULL; newString = (char *) malloc(strlen(fromJava) + 1); strcpy(newString, fromJava); (*env)->ReleaseStringUTFChars(env, source, fromJava); return newString; } /* * JNI call to wprint to get capabilities. Returns caps converted to java. */ JNIEXPORT jint JNICALL Java_com_android_bips_ipp_Backend_nativeGetCapabilities( JNIEnv *env, jobject obj, jstring address, jint port, jstring httpResource, jstring uriScheme, jlong timeout, jobject printerCaps) { jint result; printer_capabilities_t caps; wprint_connect_info_t connect_info; connect_info.printer_addr = copyToNewString(env, address); connect_info.uri_path = copyToNewString(env, httpResource); connect_info.uri_scheme = copyToNewString(env, uriScheme); connect_info.port_num = port; connect_info.timeout = timeout; connect_info.validate_certificate = NULL; LOGI("nativeGetCapabilities for %s JNIenv is %p", connect_info.printer_addr, env); // This call may take a while, and the JNI may be torn down when we return result = wprintGetCapabilities(&connect_info, &caps); if (connect_info.printer_addr) free((char *) connect_info.printer_addr); if (connect_info.uri_path) free((char *) connect_info.uri_path); if (connect_info.uri_scheme) free((char *) connect_info.uri_scheme); if (!wprintIsRunning() && result == 0) { result = ERROR; } // additional IPP checks if (result == 0) { if (caps.isSupported && (caps.ippVersionMajor < 1)) { caps.isSupported = 0; } _convertPrinterCaps_to_Java(env, printerCaps, &caps); } return result; } /* * JNI call to wprint to get default job params. Returns job params converted to java. */ JNIEXPORT jint JNICALL Java_com_android_bips_ipp_Backend_nativeGetDefaultJobParameters( JNIEnv *env, jobject obj, jobject jobParams) { LOGI("nativeGetDefaultJobParameters, JNIenv is %p", env); jint result; wprint_job_params_t params; result = wprintGetDefaultJobParams(¶ms); _covertJobParams_to_Java(env, jobParams, ¶ms); return result; } /* * JNI call to wprint to get final job params. Returns final params converted to java. */ JNIEXPORT jint JNICALL Java_com_android_bips_ipp_Backend_nativeGetFinalJobParameters( JNIEnv *env, jobject obj, jobject jobParams, jobject printerCaps) { LOGI("nativeGetFinalJobParameters, JNIenv is %p", env); jint result; wprint_job_params_t params; printer_capabilities_t caps; _convertJobParams_to_C(env, jobParams, ¶ms); _convertPrinterCaps_to_C(env, printerCaps, &caps); LOGD("nativeGetFinalJobParameters: After _convertJobParams_to_C: res=%d, name=%s", params.pdf_render_resolution, params.job_name); result = wprintGetFinalJobParams(¶ms, &caps); _covertJobParams_to_Java(env, jobParams, ¶ms); return result; } /* * Convert certificate (if present) from printer capabilities into job_params. */ static void _convertCertificate(JNIEnv *env, jobject printerCaps, wprint_job_params_t *params) { params->certificate = NULL; jbyteArray certificate = (jbyteArray) (*env)->GetObjectField(env, printerCaps, _LocalPrinterCapabilitiesField__certificate); if (certificate) { params->certificate_len = (*env)->GetArrayLength(env, certificate); params->certificate = malloc(params->certificate_len); if (params->certificate) { jbyte *certificateBytes = (*env)->GetByteArrayElements(env, certificate, NULL); memcpy(params->certificate, certificateBytes, params->certificate_len); (*env)->ReleaseByteArrayElements(env, certificate, certificateBytes, JNI_ABORT); } } } /* * JNI call to wprint to start a print job. Takes connection params, job params, caps, and file * array to complete the job */ JNIEXPORT jint JNICALL Java_com_android_bips_ipp_Backend_nativeStartJob( JNIEnv *env, jobject obj, jstring address, jint port, jstring mimeType, jobject jobParams, jobject printerCaps, jobject fileArray, jstring jobDebugDir, jstring scheme) { LOGI("nativeStartJob, JNIenv is %p", env); jint result = ERROR; wJob_t job_handle = ERROR; bool hasFiles = false; wprint_job_params_t params; printer_capabilities_t caps; _convertJobParams_to_C(env, jobParams, ¶ms); _convertPrinterCaps_to_C(env, printerCaps, &caps); _convertCertificate(env, printerCaps, ¶ms); LOGD("nativeStartJob: After _convertJobParams_to_C: res=%d, name=%s", params.pdf_render_resolution, params.job_name); const char *addressStr = (*env)->GetStringUTFChars(env, address, NULL); const char *mimeTypeStr = (*env)->GetStringUTFChars(env, mimeType, NULL); const char *dataDirStr = (*env)->GetStringUTFChars(env, _fakeDir, NULL); const char *schemeStr = (*env)->GetStringUTFChars(env, scheme, NULL); jsize len = 0; jobjectArray array; if (fileArray) { array = (jobjectArray) fileArray; len = (*env)->GetArrayLength(env, array); hasFiles = (len > 0); } int index = 0, pageIndex, incrementor; int page_range_arr[len]; // Initialize page_range_arr (address defect reported by Coverity scans) memset((char *) page_range_arr, 0, sizeof(int) * len); int pdf_pages_ary[len]; int pages_ary[len][MAX_NUM_PAGES]; if (hasFiles) { result = OK; for (pageIndex = 0; ((result == OK) && (pageIndex < len)); pageIndex++) { jstring page = (jstring) (*env)->GetObjectArrayElement(env, array, pageIndex); const char *pageStr = (*env)->GetStringUTFChars(env, page, NULL); if (pageStr == NULL) { result = ERROR; } else { int page_count = 0; if (_get_pdf_page_count(mimeTypeStr, &page_count, pageStr)) { pdf_pages_ary[pageIndex] = page_count; page_range_arr[pageIndex] = 0; char page_range_str[MAX_NUM_PAGES]; memset(page_range_str, 0, MAX_NUM_PAGES); _get_pdf_page_range(env, jobParams, &pages_ary[pageIndex][0], pdf_pages_ary[pageIndex], &page_range_arr[pageIndex], page_range_str); } } (*env)->ReleaseStringUTFChars(env, page, pageStr); } jstring page = (jstring) (*env)->GetObjectArrayElement(env, array, index); const char *pageStr = (*env)->GetStringUTFChars(env, page, NULL); if (pageStr == NULL) { result = ERROR; } if (len == 1) { if (_is_pdf_doc((char *) mimeTypeStr, (char *) pageStr)) { if (page_range_arr[0] == 1) { LOGI("smart duplex, disabling duplex"); params.duplex = DUPLEX_MODE_NONE; } } else { LOGI("smart duplex, disabling duplex"); params.duplex = DUPLEX_MODE_NONE; } } (*env)->ReleaseStringUTFChars(env, page, pageStr); const char *jobDebugDirStr = NULL; if (jobDebugDir != NULL) { jobDebugDirStr = (*env)->GetStringUTFChars(env, jobDebugDir, NULL); } result = wprintStartJob(addressStr, port, ¶ms, &caps, (char *) mimeTypeStr, (char *) dataDirStr, _wprint_callback_fn, jobDebugDirStr, schemeStr); if (result == ERROR) { LOGE("failed to start job: error code :%d", errno); } if ((jobDebugDir != NULL) && (jobDebugDirStr != NULL)) { (*env)->ReleaseStringUTFChars(env, jobDebugDir, jobDebugDirStr); } } else { LOGE("empty file list"); } if (result != ERROR) { job_handle = (wJob_t) result; // register job handle with service if (caps.faceDownTray || params.duplex) { index = 0; incrementor = 1; } else { index = len - 1; incrementor = -1; } result = OK; for (pageIndex = 1; ((result == OK) && (pageIndex <= len)); pageIndex++) { jstring page = (jstring) (*env)->GetObjectArrayElement(env, array, index); const char *pageStr = (*env)->GetStringUTFChars(env, page, NULL); if (pageStr == NULL) { result = ERROR; } else { if (_is_pdf_doc((char *) mimeTypeStr, (char *) pageStr)) { result = _print_pdf_pages(job_handle, &caps, params.duplex, (char *) pageStr, page_range_arr[index], pages_ary[index]); } else { result = wprintPage(job_handle, pageIndex, (char *) pageStr, false, false, 0, 0, 0, 0); } } (*env)->ReleaseStringUTFChars(env, page, pageStr); index += incrementor; } wprintPage(job_handle, pageIndex, NULL, true, false, 0, 0, 0, 0); if (result != OK) { LOGE("failed to add some pages, aborting job"); wprintCancelJob(job_handle); wprintEndJob(job_handle); job_handle = ERROR; } } if (params.certificate) { free(params.certificate); } (*env)->ReleaseStringUTFChars(env, mimeType, mimeTypeStr); (*env)->ReleaseStringUTFChars(env, address, addressStr); (*env)->ReleaseStringUTFChars(env, _fakeDir, dataDirStr); (*env)->ReleaseStringUTFChars(env, scheme, schemeStr); return job_handle; } /* * JNI call to wprint to end a print job */ JNIEXPORT jint JNICALL Java_com_android_bips_ipp_Backend_nativeEndJob( JNIEnv *env, jobject obj, jint job_handle) { LOGI("nativeEndJob, JNIenv is %p", env); return wprintEndJob((wJob_t) job_handle); } /* * JNI call to wprint to cancel a print job */ JNIEXPORT jint JNICALL Java_com_android_bips_ipp_Backend_nativeCancelJob( JNIEnv *env, jobject obj, jint job_handle) { LOGI("nativeCancelJob, JNIenv is %p", env); return wprintCancelJob((wJob_t) job_handle); } /* * JNI call to wprint to exit */ JNIEXPORT jint JNICALL Java_com_android_bips_ipp_Backend_nativeExit(JNIEnv *env, jobject obj) { LOGI("nativeExit, JNIenv is %p", env); (*env)->DeleteGlobalRef(env, _LocalJobParamsClass); (*env)->DeleteGlobalRef(env, _LocalPrinterCapabilitiesClass); (*env)->DeleteGlobalRef(env, _JobCallbackParamsClass); if (_callbackReceiver) { (*env)->DeleteGlobalRef(env, _callbackReceiver); } if (_JobCallbackClass) { (*env)->DeleteGlobalRef(env, _JobCallbackClass); } (*env)->DeleteGlobalRef(env, _fakeDir); (*env)->DeleteGlobalRef(env, _PrintServiceStringsClass); pdf_render_deinit(env); return wprintExit(); } /* * Sets app name/version and os name */ JNIEXPORT void JNICALL Java_com_android_bips_ipp_Backend_nativeSetSourceInfo( JNIEnv *env, jobject obj, jstring appName, jstring appVersion, jstring osName) { LOGI("nativeSetSourceInfo, JNIenv is %p", env); const char *appNameStr = (*env)->GetStringUTFChars(env, appName, NULL); const char *appVersionStr = (*env)->GetStringUTFChars(env, appVersion, NULL); const char *osNameStr = (*env)->GetStringUTFChars(env, osName, NULL); wprintSetSourceInfo(appNameStr, appVersionStr, osNameStr); (*env)->ReleaseStringUTFChars(env, appName, appNameStr); (*env)->ReleaseStringUTFChars(env, appVersion, appVersionStr); (*env)->ReleaseStringUTFChars(env, osName, osNameStr); }