/**
* Create Java String object from the specified pcsl_string.
*
* @param pcsl_str pointer to the pcsl_string instance
* @param java_str pointer to the Java String instance
* @return status of the operation
*/
pcsl_string_status midp_jstring_from_pcsl_string(KNIDECLARGS
const pcsl_string * pcsl_str,
jstring java_str) {
if (pcsl_str == NULL) {
KNI_ReleaseHandle(java_str);
return PCSL_STRING_EINVAL;
} else {
const jsize length = pcsl_string_utf16_length(pcsl_str);
if (length < 0) {
KNI_ReleaseHandle(java_str);
return PCSL_STRING_EINVAL;
} else {
const jchar * buffer = pcsl_string_get_utf16_data(pcsl_str);
if (buffer == NULL) {
KNI_ReleaseHandle(java_str);
return PCSL_STRING_ERR;
} else {
KNI_NewString(buffer, length, java_str);
return PCSL_STRING_OK;
}
}
}
}
/**
* Writes string to the file.
*
* @param string string to be written
* @return number of bytes written
*/
static int write_string(const pcsl_string* string) {
int size = pcsl_string_utf16_length(string) * sizeof(jchar);
const jchar *buf = pcsl_string_get_utf16_data(string);
storageWrite(&io_error_message, table_file, (char *)&size, sizeof(int));
storageWrite(&io_error_message, table_file, (char *)buf, size);
pcsl_string_release_utf16_data(buf, string);
return sizeof(int) + size;
}
/**
* Utility for serialized handler appending.
*/
static void appendSerializedCH(const JSR211_CH* ch, jchar* buf) {
jsize n;
n = pcsl_string_utf16_length(&(ch->id));
if (n > 0) {
pcsl_string_convert_to_utf16(&(ch->id), buf, n+1, &n);
buf += n;
}
*buf++ = '\n';
n = pcsl_string_utf16_length(&(ch->class_name));
if (n > 0) {
pcsl_string_convert_to_utf16(&(ch->class_name), buf, n+1, &n);
buf += n;
}
*buf++ = '\n';
*buf++ = (jchar)(ch->suite_id >> 16);
*buf++ = (jchar)ch->suite_id;
*buf = (jchar)ch->flag;
}
/**
* compare_two_strings wrapper.
* Reads a string from a current field of a current
* record and compares it with a passed value.
*
* @param key compare key
* @param case_sensitive case sensivity flag
* @param cond internal ID of comparision mode
* @return 1 if strings are equal (for the given mode)
*/
static int compare_string(const pcsl_string* search_key,
jsr211_boolean case_sensitive, find_condition cond) {
pcsl_string string = PCSL_STRING_NULL_INITIALIZER;
int compare_result;
int exact_result, first_result;
int equal_count, string_len;
read_string(&string);
string_len = pcsl_string_utf16_length(&string);
compare_result = cond != find_last ?
compare_two_strings(&string, search_key, case_sensitive):
pcsl_string_ends_with(search_key, &string);
pcsl_string_free(&string);
exact_result = compare_result == 0;
if (cond == find_last) {
return compare_result;
}
if (cond == find_exact) {
return exact_result;
}
equal_count = compare_result - 1;
first_result = (equal_count == string_len) || exact_result;
if (cond == find_first) {
return first_result;
}
if (cond == find_test) {
return first_result || equal_count == pcsl_string_utf16_length(search_key);
}
return 0;
}
/**
* Compares two MIDP strings.
*
* The distinction from midpStringCmp is a posibility of
* partly equal strings recognition
*
* @param str1 the first string to be comapred
* @param str2 the second string to be comapred
* @param case_sensitive indicates case sensivity
* @return 0 if strings are equals; if strings are
* different returns number of the first different symbol
*/
static int compare_two_strings(const pcsl_string *str1, const pcsl_string *str2,
jsr211_boolean case_sensitive) {
const jchar *buf1, *buf2, *cur1, *cur2;
int i, n, res;
cur1 = buf1 = pcsl_string_get_utf16_data(str1);
cur2 = buf2 = pcsl_string_get_utf16_data(str2);
n = pcsl_string_utf16_length(str1);
i = pcsl_string_utf16_length(str2);
res = n == i? 0: n < i? n: i;
if (res != 0) {
n = res++;
}
i = 0;
if (!case_sensitive) {
while (i++ < n) {
if (to_lower_case(*cur1++) != to_lower_case(*cur2++)) {
res = i;
break;
}
}
} else {
while (i++ < n) {
if (*cur1++ != *cur2++) {
res = i;
break;
}
}
}
pcsl_string_release_utf16_data(buf1, str1);
pcsl_string_release_utf16_data(buf2, str2);
return res;
}
/**
* The function that will be called when Java system state
* changes.
*
* @param pEventData
*/
void system_state_listener(const NamsEventData* pEventData) {
printf("--- system_state_listener(event = %d, state = %d)\n",
pEventData->event, pEventData->state);
if (pEventData->event == MIDP_NAMS_EVENT_STATE_CHANGED &&
pEventData->state == MIDP_SYSTEM_STATE_ACTIVE) {
int i;
const jchar *jchArgsForMidlet[3];
jint argsLen[3];
/* Currently we support up to 3 arguments. */
for (i = 0; i < 3; i++) {
jchArgsForMidlet[i] = pcsl_string_get_utf16_data(&argsForMidlet[i]);
argsLen[i] = pcsl_string_utf16_length(&argsForMidlet[i]);
}
GET_PCSL_STRING_DATA_AND_LENGTH(aclassNameToRun)
(void) midp_midlet_create_start_with_args(suiteIDToRun,
(const jchar*)aclassNameToRun_data,
aclassNameToRun_len,
(const jchar**)jchArgsForMidlet,
argsLen,
3,
#if ENABLE_I3_TEST
findNextEmptyMIDlet(0),
#else
/*
* There is only one application
* excepting namsTestService mode
*/
1,
#endif
NULL);
RELEASE_PCSL_STRING_DATA_AND_LENGTH
for (i = 0; i < 3; i++) {
pcsl_string_release_utf16_data(jchArgsForMidlet[i],
&argsForMidlet[i]);
}
}
/**
* Fills output result structure with string array.
* @param strArray string array.
* @param length array length.
* @param result output result structure.
* @return operation status.
*/
jsr211_result jsr211_fillStringArray(const pcsl_string* strArr, int length,
/*OUT*/ JSR211_RESULT_STRARRAY* result) {
jsize cap, len, siz; // buffer capacity, used length, requested size
jchar* buf;
if (strArr == NULL || length <= 0) {
result->len = 0;
result->buf = NULL;
} else {
_INIT_BUFFER_(buf, cap)
for (*buf = (jchar)length, len = 1; length--; len += siz, strArr++) {
siz = pcsl_string_utf16_length(strArr);
_ASSURE_BUFFER_(buf, cap, len + siz + 2)
buf[len++] = siz;
pcsl_string_convert_to_utf16(strArr, buf + len, siz+1, &siz);
}
result->len = len;
result->buf = buf;
}
return JSR211_OK;
}
/**
* Writes the file with information about the installed suites.
*
* Note that if the value of the global variable g_numberOfSuites
* is zero, the file will be truncated.
*
* @param ppszError pointer to character string pointer to accept an error
*
* @return status code: ALL_OK if no errors,
* OUT_OF_MEMORY if malloc failed
* IO_ERROR if an IO_ERROR
*/
MIDPError
write_suites_data(char** ppszError) {
MIDPError status = ALL_OK;
long bufferLen, pos;
char* buffer = NULL;
pcsl_string_status rc;
pcsl_string suitesDataFile;
MidletSuiteData* pData;
*ppszError = NULL;
/* get a full path to the _suites.dat */
rc = pcsl_string_cat(storage_get_root(INTERNAL_STORAGE_ID),
&SUITE_DATA_FILENAME, &suitesDataFile);
if (rc != PCSL_STRING_OK) {
return OUT_OF_MEMORY;
}
if (!g_numberOfSuites) {
/* truncate the file with the list of the installed suites */
status = write_file(ppszError, &suitesDataFile, buffer, 0);
pcsl_string_free(&suitesDataFile);
return status;
}
/* allocate a buffer where the information about all suites will be saved */
bufferLen = g_numberOfSuites * (sizeof(MidletSuiteData) +
MAX_VAR_SUITE_DATA_LEN);
/* space to store the number of suites */
bufferLen += sizeof(int);
buffer = (char*)pcsl_mem_malloc(bufferLen);
if (buffer == NULL) {
pcsl_string_free(&suitesDataFile);
return OUT_OF_MEMORY;
}
/* assemble the information about all suites into the allocated buffer */
pos = 0;
pData = g_pSuitesData;
*(int*)&buffer[pos] = g_numberOfSuites;
ADJUST_POS_IN_BUF(pos, bufferLen, sizeof(int));
while (pData != NULL) {
memcpy((char*)&buffer[pos], (char*)pData, MIDLET_SUITE_DATA_SIZE);
ADJUST_POS_IN_BUF(pos, bufferLen, MIDLET_SUITE_DATA_SIZE);
/* setup pJarHash */
if (pData->jarHashLen > 0) {
memcpy((char*)&buffer[pos], pData->varSuiteData.pJarHash,
pData->jarHashLen);
ADJUST_POS_IN_BUF(pos, bufferLen, pData->jarHashLen);
}
/* setup string fields */
{
int i, convertedLen;
jint strLen;
pcsl_string* pStrings[] = {
&pData->varSuiteData.midletClassName,
&pData->varSuiteData.displayName,
&pData->varSuiteData.iconName,
&pData->varSuiteData.suiteVendor,
&pData->varSuiteData.suiteName,
&pData->varSuiteData.pathToJar,
&pData->varSuiteData.pathToSettings
};
status = ALL_OK;
for (i = 0; i < (int) (sizeof(pStrings) / sizeof(pStrings[0]));
i++) {
strLen = pcsl_string_utf16_length(pStrings[i]);
/*
* We have to guarantee 4 - bytes alignment to use this:
* *(jint*)&buffer[pos] = strLen;
* on RISC CPUs.
*/
pos = SUITESTORE_ALIGN_4(pos);
*(jint*)&buffer[pos] = strLen;
ADJUST_POS_IN_BUF(pos, bufferLen, sizeof(jint));
/* assert(bufferLen > 0); */
if (strLen > 0) {
rc = pcsl_string_convert_to_utf16(pStrings[i],
(jchar*)&buffer[pos], bufferLen / sizeof(jchar),
&convertedLen);
if (rc != PCSL_STRING_OK) {
status = OUT_OF_MEMORY;
break;
}
ADJUST_POS_IN_BUF(pos, bufferLen,
convertedLen * sizeof(jchar));
}
}
}
if (status != ALL_OK) {
break;
}
pData = pData->nextEntry;
}
if (status == ALL_OK) {
/* write the buffer into the file */
status = write_file(ppszError, &suitesDataFile, buffer, pos);
}
/* cleanup */
pcsl_mem_free(buffer);
pcsl_string_free(&suitesDataFile);
return status;
}
/**
* Version string may looks like Major:Minor:Micro
*
* @param ver pcsl_string that contains a version
* @param major Major version
* @param minor Minor version
* @param micro Micro version
* @return 1 == OK
* 0 = BAD version
*/
int midpGetVersion(const pcsl_string * ver, int *major, int *minor, int *micro) {
int ma = 0;
int mi = 0;
int mc = 0;
int count = 0;
int dot_count = 0;
int segment_size = 0;
const jchar* p = NULL;
const jchar* ver_data;
jsize ver_len = pcsl_string_utf16_length(ver);
*major = -1;
*minor = -1;
*micro = -1;
if ((ver_len <= 0) || (ver_len > 8)) {
return 0;
}
printPcslStringWithMessage("ver", ver);
ver_data = pcsl_string_get_utf16_data(ver);
if (NULL == ver_data) {
return 0;
}
/* most checking done here */
for (count=0; count < ver_len; count++) {
if ((ver_data[count] >= '0') && (ver_data[count] <= '9')) {
segment_size++;
} else if (ver_data[count] == '.') {
if ((segment_size == 0) || (segment_size > 2)) {
REPORT_ERROR1(LC_AMS, "segment size wrong %d",
segment_size);
pcsl_string_release_utf16_data(ver_data, ver);
return 0;
}
dot_count++;
segment_size = 0;
} else {
pcsl_string_release_utf16_data(ver_data, ver);
return 0;
}
} /* end of for */
/* can't be more then 2 dots in version */
if (dot_count > 2) {
REPORT_ERROR1(LC_AMS, "too many dots (%d)", dot_count);
pcsl_string_release_utf16_data(ver_data, ver);
return 0;
}
/*
* Get major version
*/
for (p = ver_data, count = 0; (*p != '.') && (count < ver_len); ) {
if (*p >= '0' && *p <= '9') {
ma *= 10;
ma += *p - '0';
} else {
pcsl_string_release_utf16_data(ver_data, ver);
return 0;
}
count++;
p++;
} /* end of for */
if(*p == '.') {
p++;
count++;
}
/*
* Get minor version.
*/
for ( ; (*p != '.') && (count < ver_len); ) {
if (*p >= '0' && *p <= '9') {
mi *= 10;
mi += *p - '0';
} else {
pcsl_string_release_utf16_data(ver_data, ver);
return 0;
}
count++;
p++;
}
if(*p == '.') {
p++;
count++;
}
/*
* Get micro version; if it exists..
*/
for ( ; (*p != '.') && (count < ver_len); ) {
if (*p >= '0' && *p <= '9') {
mc *= 10;
mc += *p - '0';
} else {
pcsl_string_release_utf16_data(ver_data, ver);
return 0;
}
p++;
count++;
}
*major = ma;
*minor = mi;
*micro = mc;
pcsl_string_release_utf16_data(ver_data, ver);
return 1;
}
/**
* Utility for needed size counting.
*/
static jsize getSerializedCHSize(const JSR211_CH* ch) {
return pcsl_string_utf16_length(&(ch->id)) +
pcsl_string_utf16_length(&(ch->class_name)) + 5;
}
